Fix Pull Request comment

Reviewed-on: SteamWar/SteamWar#519
Reviewed-by: FessmLP <72+fessmlp@noreply.localhost>

.gitignore

@@ -7,8 +7,14 @@
 !gradle/wrapper/gradle-wrapper.jar
 steamwar.properties
 
+# Kotlin
+.kotlin
+
 # IntelliJ IDEA
 *.iml
+.idea
+!.idea/copyright
+!.idea/runConfigurations
 
 # VSCode
 bin/

BauSystem/BauSystem_Main/build.gradle.kts

@@ -36,6 +36,7 @@ dependencies {
     annotationProcessor(libs.classindex)
     compileOnly(project(":SpigotCore", "default"))
     compileOnly(project(":KotlinCore", "default"))
+    implementation(project(":HiderCore"))
 
     compileOnly(libs.axiom)
     compileOnly(libs.authlib)
@@ -47,7 +48,7 @@ dependencies {
     compileOnly(libs.netty)
 
     implementation(libs.luaj)
-    implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
+    // implementation(files("$projectDir/../libs/YAPION-SNAPSHOT.jar"))
 }
 
 widener {

BauSystem/BauSystem_Main/src/BauSystem.properties

@@ -35,8 +35,7 @@ SCOREBOARD_LOADER = Loader
 SCOREBOARD_TPS = TPS
 SCOREBOARD_TPS_FROZEN = §eFrozen
 SCOREBOARD_TRACE_TICKS = Ticks
-SCOREBOARD_TECHHIDER = TechHider§8: §aOn
-SCOREBOARD_XRAY = XRay§8: §aOn
+SCOREBOARD_VIEW = View§8: §a{0}
 SCOREBOARD_LOCK_TEAM = Bau Lock§8: §eTeam
 SCOREBOARD_LOCK_SUPERVISOR = Bau Lock§8: §eSupervisor
 SCOREBOARD_LOCK_TEAM_AND_SERVERTEAM = Bau Lock§8: §e(Server) Team
@@ -52,7 +51,9 @@ FLAG_ITEMS = Items
 FLAG_NO_GRAVITY = No Gravity
 FLAG_TESTBLOCK = Testblock
 FLAG_CHANGED = Changed
+FLAG_WINDCHARGE_INTERACT = Windcharge interaction
 FLAG_WATER_DESTROY = Water Destroy
+FLAG_PROJECTILE_STOPPER = Projectile Stopper
 FLAG_WATER_DESTROY_ALLOW = §coff
 FLAG_WATER_DESTROY_DENY = §aon
 FLAG_FIRE_ALLOW = §con
@@ -92,6 +93,10 @@ FLAG_TESTBLOCK_NORTH = §eNorth
 FLAG_TESTBLOCK_SOUTH = §eSouth
 FLAG_CHANGED_NO_CHANGE = §cNo
 FLAG_CHANGED_HAS_CHANGE = §aYes
+FLAG_WINDCHARGE_INTERACT_ALLOW = §aon
+FLAG_WINDCHARGE_INTERACT_DENY = §coff
+FLAG_PROJECTILE_STOPPER_ENABLED = §aon
+FLAG_PROJECTILE_STOPPER_DISABLED = §coff
 # Region
 REGION_TYPE_NORMAL = Normal
 REGION_TYPE_BUILD = Build area
@@ -827,6 +832,13 @@ REGION_TNT_OFF = §cTNT-Damage deactivated
 REGION_TNT_TB = §aTNT-Damage activated outside the building area
 REGION_TNT_BUILD_DESTROY = §cAn explosion would have destroyed blocks in the building area
 REGION_TNT_TB_DESTROY = §cAn explosion would have destroyed blocks in the testblock area
+REGION_WINDCHARGE_INTERACT_HELP = §8/§ewindcharge §8- §7Toggle the Windcharge interaction
+REGION_WINDCHARGE_INTERACT_ON = §aWindcharge interaction on
+REGION_WINDCHARGE_INTERACT_OFF = §cWindcharge interaction off
+REGION_PROJECTILE_STOPPER_HELP = §8/§eprojectilestopper §8- §7Toggle the Projectile stopper
+REGION_PROJECTILE_STOPPER_ON = §aProjectile stopper enabled
+REGION_PROJECTILE_STOPPER_OFF = §cProjectile stopper disabled
+
 AFK_KICK_MESSAGE = §cNothing happened on this server for 15 minutes.
 AFK_WARNING_MESSAGE = §cThis server will stop in one minute if you remain inactive
 SKIN_HELP = §8/§eskin §8[§7Shortform§8] §8[§7Creator§8|§epublic§8] §8[§7Name...§8] §8- §7Creates the skin schematic. Use 'public' as creator to have no creator, then copy the message to YoyoNow by clicking
@@ -1033,6 +1045,11 @@ XRAY_HELP = §8/§exray §8- §7Toggle Xray
 XRAY_GLOBAL = §cNo xray in global region
 XRAY_ON = §aXray activated
 XRAY_OFF = §cXray deactivated
+# HULLHIDER
+HULLHIDER_HELP = §8/§ehullhider §8- §7Toggle Hullhider
+HULLHIDER_GLOBAL = §cNo hullhider in global region
+HULLHIDER_ON = §aHullhider activated
+HULLHIDER_OFF = §cHullhider deactivated
 # WorldEdit
 COLORREPLACE_HELP = §8//§ecolorreplace §8[§7color§8] §8[§7color§8] §8- §7Replace all blocks of one color with another
 TYPEREPLACE_HELP = §8//§etypereplace §8[§7type§8] §8[§7type§8] §8- §7Replace all blocks of one type with another

BauSystem/BauSystem_Main/src/BauSystem_de.properties

@@ -35,8 +35,7 @@ SCOREBOARD_LOADER = Loader
 SCOREBOARD_TPS = TPS
 SCOREBOARD_TPS_FROZEN = §eEingefroren
 SCOREBOARD_TRACE_TICKS = Ticks
-SCOREBOARD_TECHHIDER = TechHider§8: §aAn
-SCOREBOARD_XRAY = XRay§8: §aAn
+SCOREBOARD_VIEW = Ansicht§8: §a{0}
 SCOREBOARD_LOCK_TEAM = Bau Lock§8: §eTeam
 SCOREBOARD_LOCK_TEAM_AND_SERVERTEAM = Bau Lock§8: §e(Server-) Team
 SCOREBOARD_LOCK_SERVERTEAM = Bau Lock§8: §eServerteam
@@ -55,6 +54,8 @@ FLAG_FREEZE_INACTIVE = §caus
 FLAG_PROTECT_ACTIVE = §aan
 FLAG_PROTECT_INACTIVE = §caus
 FLAG_WATER_DESTROY = Wasserschaden
+FLAG_PROJECTILE_STOPPER = Projektil stopper
+FLAG_WINDCHARGE_INTERACT = Windkugel interaktion
 FLAG_WATER_DESTROY_ALLOW = §cerlaubt
 FLAG_WATER_DESTROY_DENY = §aaus
 FLAG_TNT_ALLOW = §aan
@@ -81,6 +82,10 @@ FLAG_COLOR_BROWN = §eBraun
 FLAG_COLOR_GREEN = §2Grün
 FLAG_COLOR_RED = §cRot
 FLAG_COLOR_BLACK = §0Schwarz
+FLAG_WINDCHARGE_INTERACT_ALLOW = §aan
+FLAG_WINDCHARGE_INTERACT_DENY = §caus
+FLAG_PROJECTILE_STOPPER_ENABLED = §aan
+FLAG_PROJECTILE_STOPPER_DISABLED = §caus
 # Region
 REGION_TYPE_NORMAL = Normal
 REGION_TYPE_BUILD = Baubereich
@@ -765,6 +770,12 @@ REGION_TNT_OFF = §cTNT-Schaden deaktiviert
 REGION_TNT_TB = §aTNT-Schaden außerhalb Baurahmen aktiviert
 REGION_TNT_BUILD_DESTROY = §cEine Explosion hätte Blöcke im Baubereich zerstört
 REGION_TNT_TB_DESTROY = §cEine Explosion hätte Blöcke im Testblockbereich zerstört
+REGION_WINDCHARGE_INTERACT_HELP = §8/§ewindcharge §8- §7Windkugel interaktion umschalten
+REGION_WINDCHARGE_INTERACT_ON = §aWindkugel interaktion on
+REGION_WINDCHARGE_INTERACT_OFF = §cWindkugel interaktion off
+REGION_PROJECTILE_STOPPER_HELP = §8/§eprojectilestopper §8- §7
+REGION_PROJECTILE_STOPPER_ON = §aProjektiel stopper an
+REGION_PROJECTILE_STOPPER_OFF = §cProjektiel stopper aus
 AFK_KICK_MESSAGE = §cAuf diesem Server ist seit 15 Minuten nichts passiert.
 AFK_WARNING_MESSAGE = §cDieser Server wird bei weiterer Inaktivität in einer Minute gestoppt
 SKIN_HELP = §8/§eskin §8[§7Kuerzel§8] §8[§7Creator§8|§epublic§8] §8[§7Name...§8] §8- §7Erstellt die Skin Schematics. 'public' als Creator nutzen für keinen Creator, danach die nachricht an YoyoNow kopieren (mit Click kopieren)
@@ -966,6 +977,11 @@ XRAY_HELP = §8/§exray §8- §7Xray umschalten
 XRAY_GLOBAL = §cKein Xray in der globalen region
 XRAY_ON = §aXray aktiviert
 XRAY_OFF = §cXray deaktiviert
+# HULLHIDER
+HULLHIDER_HELP = §8/§ehullhider §8- §7Hullhider umschalten
+HULLHIDER_GLOBAL = §cKein Hullhider in der globalen region
+HULLHIDER_ON = §aHullhider aktiviert
+HULLHIDER_OFF = §cHullhider deaktiviert
 # WorldEdit
 COLORREPLACE_HELP = §8//§ecolorreplace §8[§7color§8] §8[§7color§8] §8- §7Ersetzt eine Farbe mit einer anderen
 TYPEREPLACE_HELP = §8//§etyreplace §8[§7type§8] §8[§7type§8] §8- §7Ersetzt einen Blockgruppe mit einer anderen

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

@@ -20,12 +20,10 @@
 package de.steamwar.bausystem;
 
 import de.steamwar.bausystem.config.BauServer;
-import de.steamwar.bausystem.configplayer.Config;
-import de.steamwar.bausystem.configplayer.ConfigConverter;
+import de.steamwar.bausystem.config.ConfigStore;
 import de.steamwar.bausystem.features.gui.BauGUI;
 import de.steamwar.bausystem.features.script.lua.SteamWarLuaPlugin;
 import de.steamwar.bausystem.features.script.lua.libs.LuaLib;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
 import de.steamwar.bausystem.features.slaves.panzern.Panzern;
 import de.steamwar.bausystem.features.slaves.panzern.PanzernAlgorithm;
 import de.steamwar.bausystem.features.tracer.TraceManager;
@@ -36,14 +34,12 @@ import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.region.RegionSystem;
 import de.steamwar.bausystem.utils.ScoreboardElement;
 import de.steamwar.bausystem.utils.TickManager;
-import de.steamwar.bausystem.worlddata.WorldData;
 import de.steamwar.command.AbstractValidator;
 import de.steamwar.command.SWCommandUtils;
 import de.steamwar.core.CRIUSleepEvent;
 import de.steamwar.core.Core;
 import de.steamwar.core.WorldIdentifier;
 import de.steamwar.core.worldedit.SteamEdit;
-import de.steamwar.core.worldedit.WorldEditRendererCUIEditor;
 import de.steamwar.linkage.AbstractLinker;
 import de.steamwar.linkage.SpigotLinker;
 import de.steamwar.message.Message;
@@ -112,12 +108,9 @@ public class BauSystem extends JavaPlugin implements Listener {
                 if (any instanceof PanzernAlgorithm) {
                     Panzern.add((PanzernAlgorithm) any);
                 }
-                if (any instanceof ConfigConverter) {
-                    Config.addConfigConverter((ConfigConverter) any);
-                }
-                if (any instanceof BoundingBoxLoader) {
-                    ((BoundingBoxLoader) any).load();
-                }
+                // if (any instanceof BoundingBoxLoader) {
+                //     ((BoundingBoxLoader) any).load();
+                // }
             }
         };
         try {
@@ -160,9 +153,8 @@ public class BauSystem extends JavaPlugin implements Listener {
     @Override
     public void onDisable() {
         linker.unlink();
-        WorldData.write();
         RegionSystem.INSTANCE.save();
-        Config.getInstance().saveAll();
+        ConfigStore.saveAll();
     }
 
     private <T extends CommandSender> AbstractValidator<T, ?> validator(Permission permission) {

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

@@ -0,0 +1,47 @@
+/*
+ *   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.config;
+
+/**
+ * Converts a config of one version into the next version, e.g. ConfigV1 to
+ * ConfigV2. The converter for the second newest version converts into the
+ * current version. Converters are registered in the {@link ConfigStore}
+ * of the config.
+ *
+ * @param <F> the config version to convert from
+ * @param <T> the config version to convert to
+ */
+public interface ConfigConverter<F extends VersionedConfig, T extends VersionedConfig> {
+
+    /**
+     * @return the version this converter converts from
+     */
+    int version();
+
+    /**
+     * Converts the config to the next version. If anything goes wrong do not
+     * silently exit this method, throw an Exception. The {@link ConfigStore}
+     * will deal with it.
+     *
+     * @param config the config to convert
+     * @return the converted config
+     */
+    T convert(F config);
+}

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

@@ -0,0 +1,364 @@
+/*
+ *   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.config;
+
+import com.google.gson.Gson;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import de.steamwar.sql.UserConfig;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+import java.io.File;
+import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.StandardCopyOption;
+import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+
+/**
+ * Loads, converts and saves a versioned config stored as JSON. Older versions
+ * are converted with the registered {@link ConfigConverter}s, legacy formats
+ * that are not JSON can be read with {@link #legacy(Predicate, Function)}.
+ * <p>
+ * A store can be bound to where the config is stored:
+ * <ul>
+ *     <li>{@link #userConfig(String)}: one config per player in the {@link UserConfig}, use {@link #get(Player)}</li>
+ *     <li>{@link #file(File)}: one config in a file, use {@link #get()}</li>
+ *     <li>unbound: use {@link #load(File)} and {@link #save(File, VersionedConfig)}</li>
+ * </ul>
+ *
+ * @param <T> the current config version
+ */
+public class ConfigStore<T extends VersionedConfig> {
+
+    private static final List<ConfigStore<?>> STORES = new ArrayList<>();
+
+    private final Class<T> type;
+    private final int version;
+    private final Supplier<T> defaultConfig;
+
+    private final Map<Integer, Class<? extends VersionedConfig>> jsonVersions = new HashMap<>();
+    private final Map<Integer, ConfigConverter<?, ?>> converters = new HashMap<>();
+    private final List<LegacyFormat> legacyFormats = new ArrayList<>();
+    private Gson gson = new Gson();
+    private Integer unversionedVersion = null;
+
+    private String userConfigKey = null;
+    private Predicate<T> removeIf = config -> false;
+    private final Map<UUID, T> playerConfigs = new ConcurrentHashMap<>();
+
+    private File file = null;
+    private File legacyFile = null;
+    private Function<String, ? extends VersionedConfig> legacyFileReader = null;
+    private T fileConfig = null;
+
+    private record LegacyFormat(Predicate<String> matches, Function<String, ? extends VersionedConfig> reader) {
+    }
+
+    public ConfigStore(Class<T> type, int version, Supplier<T> defaultConfig) {
+        this.type = type;
+        this.version = version;
+        this.defaultConfig = defaultConfig;
+        jsonVersions.put(version, type);
+        STORES.add(this);
+    }
+
+    public ConfigStore<T> gson(Gson gson) {
+        this.gson = gson;
+        return this;
+    }
+
+    /**
+     * Registers an older config version that is stored as JSON.
+     */
+    public ConfigStore<T> jsonVersion(int version, Class<? extends VersionedConfig> type) {
+        jsonVersions.put(version, type);
+        return this;
+    }
+
+    public ConfigStore<T> converter(ConfigConverter<?, ?> converter) {
+        if (converters.putIfAbsent(converter.version(), converter) != null) {
+            throw new IllegalStateException("Duplicate converter for version " + converter.version() + " of " + type.getSimpleName());
+        }
+        return this;
+    }
+
+    /**
+     * Registers a legacy format that is not JSON, stored strings matching the predicate are read by the reader.
+     */
+    public ConfigStore<T> legacy(Predicate<String> matches, Function<String, ? extends VersionedConfig> reader) {
+        legacyFormats.add(new LegacyFormat(matches, reader));
+        return this;
+    }
+
+    /**
+     * The version of stored JSON without a version field.
+     */
+    public ConfigStore<T> unversioned(int version) {
+        this.unversionedVersion = version;
+        return this;
+    }
+
+    /**
+     * Binds this store to the {@link UserConfig} with the given key, one config per player.
+     */
+    public ConfigStore<T> userConfig(String key) {
+        this.userConfigKey = key;
+        return this;
+    }
+
+    /**
+     * Removes the config from the {@link UserConfig} instead of saving it, if the predicate matches.
+     */
+    public ConfigStore<T> removeIf(Predicate<T> removeIf) {
+        this.removeIf = removeIf;
+        return this;
+    }
+
+    /**
+     * Binds this store to a single file.
+     */
+    public ConfigStore<T> file(File file) {
+        this.file = file;
+        return this;
+    }
+
+    /**
+     * Legacy file to read, if the file of this store does not exist yet.
+     */
+    public ConfigStore<T> legacyFile(File legacyFile, Function<String, ? extends VersionedConfig> reader) {
+        this.legacyFile = legacyFile;
+        this.legacyFileReader = reader;
+        return this;
+    }
+
+    /**
+     * Reads a stored config and converts it to the current version.
+     *
+     * @throws RuntimeException if the config could not be read or converted
+     */
+    public T read(String stored) {
+        for (LegacyFormat legacyFormat : legacyFormats) {
+            if (legacyFormat.matches().test(stored)) {
+                return update(legacyFormat.reader().apply(stored));
+            }
+        }
+
+        JsonObject json = JsonParser.parseString(stored).getAsJsonObject();
+        int storedVersion;
+        if (json.has("version")) {
+            storedVersion = json.get("version").getAsInt();
+        } else if (unversionedVersion != null) {
+            storedVersion = unversionedVersion;
+            json.addProperty("version", storedVersion);
+        } else {
+            throw new IllegalStateException("Missing version of " + type.getSimpleName());
+        }
+        Class<? extends VersionedConfig> storedType = jsonVersions.get(storedVersion);
+        if (storedType == null) {
+            throw new IllegalStateException("Unknown version " + storedVersion + " of " + type.getSimpleName());
+        }
+        return update(gson.fromJson(json, storedType));
+    }
+
+    public String write(T config) {
+        return gson.toJson(config);
+    }
+
+    /**
+     * Converts a config to the current version.
+     */
+    @SuppressWarnings({"unchecked", "rawtypes"})
+    public T update(VersionedConfig config) {
+        while (config.getVersion() < version) {
+            ConfigConverter converter = converters.get(config.getVersion());
+            if (converter == null) {
+                throw new IllegalStateException("No converter found for version " + config.getVersion() + " of " + type.getSimpleName());
+            }
+            VersionedConfig converted = converter.convert(config);
+            if (converted.getVersion() <= config.getVersion()) {
+                throw new IllegalStateException("Version did not increase after conversion of version " + config.getVersion() + " of " + type.getSimpleName());
+            }
+            config = converted;
+        }
+        if (!type.isInstance(config)) {
+            throw new IllegalStateException("Version " + config.getVersion() + " is not the current version of " + type.getSimpleName());
+        }
+        return type.cast(config);
+    }
+
+    /**
+     * @return the config stored in the file, or the default config if the file is missing or empty
+     * @throws RuntimeException if the config could not be read or converted
+     */
+    public T load(File file) throws IOException {
+        if (file.length() == 0) {
+            return defaultConfig.get();
+        }
+        return read(Files.readString(file.toPath(), StandardCharsets.UTF_8));
+    }
+
+    public void save(File file, T config) throws IOException {
+        Files.writeString(file.toPath(), write(config), StandardCharsets.UTF_8);
+    }
+
+    /**
+     * Get the config of a player, loads it from the {@link UserConfig} and converts it if necessary.
+     */
+    public T get(Player player) {
+        requireUserConfig();
+        return playerConfigs.computeIfAbsent(player.getUniqueId(), this::loadPlayer);
+    }
+
+    /**
+     * Save the config of a player, this does not unload the config.
+     */
+    public void save(Player player) {
+        requireUserConfig();
+        T config = playerConfigs.get(player.getUniqueId());
+        if (config != null) {
+            savePlayer(player.getUniqueId(), config);
+        }
+    }
+
+    /**
+     * Save and unload the config of a player.
+     */
+    public void unload(Player player) {
+        if (userConfigKey == null) return;
+        T config = playerConfigs.remove(player.getUniqueId());
+        if (config != null) {
+            savePlayer(player.getUniqueId(), config);
+        }
+    }
+
+    private T loadPlayer(UUID uuid) {
+        String stored = UserConfig.getConfig(uuid, userConfigKey);
+        if (stored == null) {
+            return defaultConfig.get();
+        }
+        try {
+            return read(stored);
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not load " + type.getSimpleName() + " of " + uuid, e);
+            return defaultConfig.get();
+        }
+    }
+
+    private void savePlayer(UUID uuid, T config) {
+        if (removeIf.test(config)) {
+            UserConfig.removePlayerConfig(uuid, userConfigKey);
+        } else {
+            UserConfig.updatePlayerConfig(uuid, userConfigKey, write(config));
+        }
+    }
+
+    private void requireUserConfig() {
+        if (userConfigKey == null) {
+            throw new IllegalStateException(type.getSimpleName() + " is not stored in the UserConfig");
+        }
+    }
+
+    /**
+     * Get the config of the file of this store, loads it and converts it if necessary.
+     */
+    public T get() {
+        requireFile();
+        if (fileConfig == null) {
+            fileConfig = loadFile();
+            save();
+        }
+        return fileConfig;
+    }
+
+    /**
+     * Save the config to the file of this store, if it was loaded.
+     */
+    public void save() {
+        requireFile();
+        if (fileConfig == null) return;
+        try {
+            save(file, fileConfig);
+        } catch (IOException e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not write " + file, e);
+        }
+    }
+
+    private T loadFile() {
+        try {
+            if (file.length() != 0) {
+                return load(file);
+            }
+            if (legacyFile != null && legacyFile.length() != 0) {
+                return update(legacyFileReader.apply(Files.readString(legacyFile.toPath(), StandardCharsets.UTF_8)));
+            }
+            return defaultConfig.get();
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not load " + file + ", using default " + type.getSimpleName(), e);
+            backupBrokenFile();
+            return defaultConfig.get();
+        }
+    }
+
+    private void backupBrokenFile() {
+        if (file.length() == 0) return;
+        try {
+            Files.copy(file.toPath(), new File(file.getParentFile(), file.getName() + ".broken").toPath(), StandardCopyOption.REPLACE_EXISTING);
+        } catch (IOException e) {
+            Bukkit.getLogger().log(Level.SEVERE, "Could not backup broken " + file, e);
+        }
+    }
+
+    private void requireFile() {
+        if (file == null) {
+            throw new IllegalStateException(type.getSimpleName() + " is not bound to a file");
+        }
+    }
+
+    static void unloadAll(Player player) {
+        STORES.forEach(store -> store.unload(player));
+    }
+
+    /**
+     * Saves every loaded config and unloads the configs of the players.
+     */
+    public static void saveAll() {
+        for (ConfigStore<?> store : STORES) {
+            if (store.userConfigKey != null) {
+                store.playerConfigs.forEach((uuid, config) -> saveUnchecked(store, uuid, config));
+                store.playerConfigs.clear();
+            }
+            if (store.file != null) {
+                store.save();
+            }
+        }
+    }
+
+    @SuppressWarnings("unchecked")
+    private static <T extends VersionedConfig> void saveUnchecked(ConfigStore<T> store, UUID uuid, Object config) {
+        store.savePlayer(uuid, (T) config);
+    }
+}

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

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,21 +17,29 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.core.events;
+package de.steamwar.bausystem.config;
 
-import de.steamwar.core.Core;
+import de.steamwar.core.CRIUSleepEvent;
 import de.steamwar.linkage.Linked;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 
+/**
+ * Saves and unloads the configs of the {@link ConfigStore}s bound to the UserConfig
+ * when a player quits, configs are loaded on first use.
+ */
 @Linked
-public class ChattingEvent implements Listener {
+public class ConfigStoreListener implements Listener {
 
-    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
-    private void onChat(AsyncPlayerChatEvent event) {
-        event.setCancelled(true);
-        Core.MESSAGE.broadcastPrefixless("LOCAL_CHAT", event.getPlayer().getDisplayName(), event.getMessage());
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        ConfigStore.unloadAll(event.getPlayer());
+    }
+
+    @EventHandler
+    public void onCRIUSleep(CRIUSleepEvent event) {
+        ConfigStore.saveAll();
     }
 }

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

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -17,9 +17,13 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.bausystem.features.slaves.laufbau;
+package de.steamwar.bausystem.config;
 
-public interface BoundingBoxLoader {
+/**
+ * Common interface of every version of a config stored by a {@link ConfigStore},
+ * the current version (e.g. Config) and every older version (ConfigV1, ConfigV2, ...).
+ */
+public interface VersionedConfig {
 
-    void load();
+    int getVersion();
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/config/legacy/YapionItemDeserializer.java

@@ -0,0 +1,95 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.config.legacy;
+
+import lombok.experimental.UtilityClass;
+import org.bukkit.configuration.serialization.ConfigurationSerialization;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Deserializes {@link ItemStack}s that were serialized by YAPION, read with {@link YapionReader}.
+ */
+@UtilityClass
+@Deprecated
+public class YapionItemDeserializer {
+
+    private static final String TYPE_IDENTIFIER = "@type";
+
+    public ItemStack deserializeItem(Object yapion) {
+        if (yapion == null) return null;
+        Object result = deserialize(yapion);
+        if (result instanceof ItemStack itemStack) return itemStack;
+        throw new IllegalArgumentException("Not an ItemStack: " + result);
+    }
+
+    private Object deserialize(Object yapion) {
+        if (yapion instanceof List<?> list) {
+            List<Object> result = new ArrayList<>();
+            list.forEach(o -> result.add(deserialize(o)));
+            return result;
+        }
+        if (yapion instanceof YapionReader.YapionMap map) {
+            Map<Object, Object> result = new LinkedHashMap<>();
+            map.entries().forEach((key, value) -> result.put(deserialize(key), deserialize(value)));
+            return result;
+        }
+        if (yapion instanceof Map<?, ?> object) {
+            return deserializeObject(object);
+        }
+        return yapion;
+    }
+
+    private Object deserializeObject(Map<?, ?> object) {
+        Map<String, Object> data = new LinkedHashMap<>();
+        object.forEach((key, value) -> {
+            if (!TYPE_IDENTIFIER.equals(key)) data.put((String) key, deserialize(value));
+        });
+
+        if (!(object.get(TYPE_IDENTIFIER) instanceof String type)) {
+            return data;
+        }
+
+        Class<?> javaType = javaUtilClass(type);
+        if (javaType != null && Collection.class.isAssignableFrom(javaType)) {
+            return data.getOrDefault("values", new ArrayList<>());
+        }
+        if (javaType != null && Map.class.isAssignableFrom(javaType)) {
+            return data.containsKey("values") ? data.get("values") : data;
+        }
+
+        data.put(ConfigurationSerialization.SERIALIZED_TYPE_KEY, type.equals("org.bukkit.inventory.meta.ItemMeta") ? "ItemMeta" : type);
+        return ConfigurationSerialization.deserializeObject(data);
+    }
+
+    private Class<?> javaUtilClass(String type) {
+        if (!type.startsWith("java.util.")) return null;
+        try {
+            return Class.forName(type);
+        } catch (ClassNotFoundException e) {
+            return null;
+        }
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/config/legacy/YapionReader.java

@@ -0,0 +1,323 @@
+/*
+ *   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.config.legacy;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.regex.Pattern;
+
+/**
+ * Minimal reader for the legacy YAPION format, only used to migrate old data.
+ * <p>
+ * The result is built from plain java objects:
+ * <ul>
+ *     <li>YAPION objects {@code {key(value)}} become a {@link LinkedHashMap} of String to value</li>
+ *     <li>YAPION arrays {@code [a,b]} become a {@link List}</li>
+ *     <li>YAPION maps {@code <(a):(b)>} become a {@link YapionMap}</li>
+ *     <li>YAPION values {@code (value)} become null, Boolean, Number or String</li>
+ * </ul>
+ */
+@Deprecated
+public class YapionReader {
+
+    private static final Pattern INTEGER = Pattern.compile("[-+]?\\d+");
+    private static final Pattern DECIMAL = Pattern.compile("[-+]?(\\d+\\.\\d*|\\.\\d+|\\d+)([eE][-+]?\\d+)?");
+
+    public record YapionMap(Map<Object, Object> entries) {
+    }
+
+    public static Map<String, Object> parse(String yapion) {
+        YapionReader reader = new YapionReader(yapion);
+        reader.skipWhitespace();
+        Map<String, Object> result = reader.readObject();
+        reader.skipWhitespace();
+        if (reader.index != yapion.length()) {
+            throw reader.error("Unexpected trailing content");
+        }
+        return result;
+    }
+
+    public static double getDouble(Map<?, ?> object, String key, double defaultValue) {
+        return object.get(key) instanceof Number value ? value.doubleValue() : defaultValue;
+    }
+
+    public static int getInt(Map<?, ?> object, String key, int defaultValue) {
+        return object.get(key) instanceof Number value ? value.intValue() : defaultValue;
+    }
+
+    public static boolean getBoolean(Map<?, ?> object, String key, boolean defaultValue) {
+        return object.get(key) instanceof Boolean value ? value : defaultValue;
+    }
+
+    public static String getString(Map<?, ?> object, String key, String defaultValue) {
+        return object.get(key) instanceof String value ? value : defaultValue;
+    }
+
+    /**
+     * @return the entries of the array that are YAPION objects
+     */
+    public static List<Map<?, ?>> getObjects(Map<?, ?> object, String key) {
+        List<Map<?, ?>> objects = new ArrayList<>();
+        if (object.get(key) instanceof List<?> array) {
+            array.forEach(o -> {
+                if (o instanceof Map<?, ?> map) objects.add(map);
+            });
+        }
+        return objects;
+    }
+
+    private final String input;
+    private int index = 0;
+
+    private YapionReader(String input) {
+        this.input = input;
+    }
+
+    private Object readAny() {
+        return switch (peek()) {
+            case '{' -> readObject();
+            case '[' -> readArray();
+            case '<' -> readMap();
+            case '(' -> readValue();
+            default -> throw error("Expected '{', '[', '<' or '('");
+        };
+    }
+
+    private Map<String, Object> readObject() {
+        expect('{');
+        Map<String, Object> object = new LinkedHashMap<>();
+        while (true) {
+            skipWhitespace();
+            if (peek() == '}') {
+                index++;
+                return object;
+            }
+            StringBuilder key = new StringBuilder();
+            while (true) {
+                char c = peek();
+                if (c == '(' || c == '{' || c == '[' || c == '<') break;
+                if (c == '}') throw error("Key without value");
+                key.append(readChar());
+            }
+            object.put(key.toString(), readAny());
+        }
+    }
+
+    private List<Object> readArray() {
+        expect('[');
+        List<Object> array = new ArrayList<>();
+        skipWhitespace();
+        if (peek() == ']') {
+            index++;
+            return array;
+        }
+        while (true) {
+            int start = index;
+            skipWhitespace();
+            char c = peek();
+            if (c == '{' || c == '[' || c == '<' || c == '(') {
+                array.add(readAny());
+                skipWhitespace();
+            } else {
+                // Whitespace is part of plain values
+                index = start;
+                StringBuilder value = new StringBuilder();
+                while (peek() != ',' && peek() != ']') {
+                    value.append(readChar());
+                }
+                array.add(typed(value.toString()));
+            }
+            char separator = input.charAt(index++);
+            if (separator == ']') return array;
+            if (separator != ',') throw error("Expected ',' or ']'");
+        }
+    }
+
+    private YapionMap readMap() {
+        expect('<');
+        Map<Object, Object> map = new LinkedHashMap<>();
+        while (true) {
+            skipWhitespace();
+            if (peek() == '>') {
+                index++;
+                return new YapionMap(map);
+            }
+            Object key = readAny();
+            skipWhitespace();
+            expect(':');
+            skipWhitespace();
+            map.put(key, readAny());
+        }
+    }
+
+    /**
+     * YAPION does not escape parentheses in values, balanced parentheses are part of the value.
+     * A backslash only escapes a backslash, a unicode sequence or a control character, otherwise it is kept.
+     */
+    private Object readValue() {
+        expect('(');
+        StringBuilder value = new StringBuilder();
+        int depth = 0;
+        while (true) {
+            char c = peek();
+            if (c == '\\') {
+                value.append(readValueEscape());
+                continue;
+            }
+            index++;
+            if (c == '(') {
+                depth++;
+            } else if (c == ')') {
+                if (depth == 0) break;
+                depth--;
+            }
+            value.append(c);
+        }
+        return typed(value.toString());
+    }
+
+    private String readValueEscape() {
+        index++;
+        if (index >= input.length()) return "\\";
+        char escaped = input.charAt(index);
+        switch (escaped) {
+            case '\\', '(', ')':
+                index++;
+                return String.valueOf(escaped);
+            case 'n':
+                index++;
+                return "\n";
+            case 't':
+                index++;
+                return "\t";
+            case 'r':
+                index++;
+                return "\r";
+            case 'u':
+                if (index + 5 <= input.length() && input.substring(index + 1, index + 5).matches("[0-9a-fA-F]{4}")) {
+                    char unicode = (char) Integer.parseInt(input.substring(index + 1, index + 5), 16);
+                    index += 5;
+                    return String.valueOf(unicode);
+                }
+                return "\\";
+            default:
+                return "\\";
+        }
+    }
+
+    /**
+     * Reads one character of a key or plain array value, resolving backslash escapes.
+     * A backslash that does not escape anything is kept, as the old player config
+     * collapsed escaped backslashes into a single one.
+     */
+    private char readChar() {
+        char c = input.charAt(index++);
+        if (c != '\\') return c;
+        if (index >= input.length()) throw error("Unterminated escape");
+        char escaped = input.charAt(index);
+        switch (escaped) {
+            case 'n':
+                index++;
+                return '\n';
+            case 't':
+                index++;
+                return '\t';
+            case 'r':
+                index++;
+                return '\r';
+            case 'u':
+                if (index + 5 <= input.length() && input.substring(index + 1, index + 5).matches("[0-9a-fA-F]{4}")) {
+                    char unicode = (char) Integer.parseInt(input.substring(index + 1, index + 5), 16);
+                    index += 5;
+                    return unicode;
+                }
+                return '\\';
+            case '\\', ',', ' ', '(', ')', '{', '}', '[', ']', '<', '>', '"', ':', '@':
+                index++;
+                return escaped;
+            default:
+                return '\\';
+        }
+    }
+
+    private static Object typed(String value) {
+        if (value.equals("null")) return null;
+        if (value.equals("true")) return true;
+        if (value.equals("false")) return false;
+        if (value.length() >= 2 && value.startsWith("\"") && value.endsWith("\"")) {
+            return value.substring(1, value.length() - 1);
+        }
+        try {
+            if (INTEGER.matcher(value).matches()) {
+                long l = Long.parseLong(value);
+                if (l >= Integer.MIN_VALUE && l <= Integer.MAX_VALUE) return (int) l;
+                return l;
+            }
+            if (value.length() > 1) {
+                String number = value.substring(0, value.length() - 1);
+                switch (value.charAt(value.length() - 1)) {
+                    case 'L':
+                        if (INTEGER.matcher(number).matches()) return Long.parseLong(number);
+                        break;
+                    case 'S':
+                        if (INTEGER.matcher(number).matches()) return Short.parseShort(number);
+                        break;
+                    case 'B':
+                        if (INTEGER.matcher(number).matches()) return Byte.parseByte(number);
+                        break;
+                    case 'F':
+                        if (DECIMAL.matcher(number).matches()) return Float.parseFloat(number);
+                        break;
+                    case 'D':
+                        if (DECIMAL.matcher(number).matches()) return Double.parseDouble(number);
+                        break;
+                    default:
+                        break;
+                }
+            }
+            if (DECIMAL.matcher(value).matches()) return Double.parseDouble(value);
+        } catch (NumberFormatException e) {
+            // Not a number, fall through to String
+        }
+        return value;
+    }
+
+    private void skipWhitespace() {
+        while (index < input.length() && Character.isWhitespace(input.charAt(index))) {
+            index++;
+        }
+    }
+
+    private char peek() {
+        if (index >= input.length()) throw error("Unexpected end of input");
+        return input.charAt(index);
+    }
+
+    private void expect(char c) {
+        if (peek() != c) throw error("Expected '" + c + "'");
+        index++;
+    }
+
+    private IllegalArgumentException error(String message) {
+        return new IllegalArgumentException(message + " at index " + index);
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/config/serializer/ItemStackTypeAdapter.java

@@ -0,0 +1,63 @@
+/*
+ *   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.config.serializer;
+
+import com.google.gson.TypeAdapter;
+import com.google.gson.stream.JsonReader;
+import com.google.gson.stream.JsonToken;
+import com.google.gson.stream.JsonWriter;
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.ItemStack;
+
+import java.io.IOException;
+import java.util.Base64;
+import java.util.logging.Level;
+
+/**
+ * Stores an {@link ItemStack} as Base64 of {@link ItemStack#serializeAsBytes()}, which
+ * contains the data version and gets upgraded on newer Minecraft versions.
+ * Empty items are stored as null, items that can't be read are deserialized as null.
+ */
+public class ItemStackTypeAdapter extends TypeAdapter<ItemStack> {
+
+    @Override
+    public void write(JsonWriter out, ItemStack itemStack) throws IOException {
+        if (itemStack == null || itemStack.isEmpty()) {
+            out.nullValue();
+            return;
+        }
+        out.value(Base64.getEncoder().encodeToString(itemStack.serializeAsBytes()));
+    }
+
+    @Override
+    public ItemStack read(JsonReader in) throws IOException {
+        if (in.peek() == JsonToken.NULL) {
+            in.nextNull();
+            return null;
+        }
+        String value = in.nextString();
+        try {
+            return ItemStack.deserializeBytes(Base64.getDecoder().decode(value));
+        } catch (Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "Could not deserialize ItemStack", e);
+            return null;
+        }
+    }
+}

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

@@ -1,7 +1,7 @@
 /*
  *   This file is a part of the SteamWar software.
  *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
  *
  *   This program is free software: you can redistribute it and/or modify
  *   it under the terms of the GNU Affero General Public License as published by
@@ -19,129 +19,77 @@
 
 package de.steamwar.bausystem.configplayer;
 
-import de.steamwar.bausystem.configplayer.serializer.ConfigurationSerializableSerializer;
-import de.steamwar.linkage.Linked;
-import de.steamwar.sql.UserConfig;
+import com.google.gson.GsonBuilder;
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.config.serializer.ItemStackTypeAdapter;
+import de.steamwar.bausystem.configplayer.converter.ConfigV1ToV2Converter;
+import de.steamwar.bausystem.features.hotbar.DefaultHotbar;
+import lombok.AccessLevel;
 import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import yapion.hierarchy.output.StringOutput;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
-import yapion.serializing.SerializeManager;
+import lombok.Setter;
+import org.bukkit.inventory.ItemStack;
 
 import java.util.HashMap;
 import java.util.Map;
-import java.util.UUID;
-import java.util.logging.Level;
 
-@Linked
-public class Config implements Listener {
+/**
+ * The current player config. It is stored as JSON, fields missing in the
+ * stored JSON keep the default value of their initializer, so adding a new
+ * field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to ConfigV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION},
+ * write a {@link ConfigConverter} from the copy to this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class Config implements VersionedConfig {
 
-    static {
-        SerializeManager.add(new ConfigurationSerializableSerializer());
-    }
+    public static final int VERSION = 2;
 
-    @Getter
-    private static Config instance;
+    public static final ConfigStore<Config> STORE = new ConfigStore<>(Config.class, VERSION, Config::new)
+            .gson(new GsonBuilder().registerTypeHierarchyAdapter(ItemStack.class, new ItemStackTypeAdapter()).create())
+            .legacy(s -> s.startsWith("{@version(1)"), ConfigV1::parse)
+            .converter(new ConfigV1ToV2Converter())
+            .userConfig("bausystem");
 
-    {
-        instance = this;
-    }
-
-    private final Map<UUID, YAPIONObject> playerConfigurations = new HashMap<>();
-
-    private static final Map<Integer, ConfigConverter> CONFIG_CONVERTER_MAP = new HashMap<>();
-
-    public static void addConfigConverter(ConfigConverter configConverter) {
-        CONFIG_CONVERTER_MAP.putIfAbsent(configConverter.version(), configConverter);
-    }
-
-    @EventHandler
-    public void onPlayerJoin(PlayerJoinEvent event) {
-        get(event.getPlayer());
-    }
-
-    @EventHandler
-    public void onPlayerQuit(PlayerQuitEvent event) {
-        save(event.getPlayer());
-        playerConfigurations.remove(event.getPlayer().getUniqueId());
-    }
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
 
     /**
-     * Get a PlayerConfig, optionally loads it from the DataBase and migrates it if necessary.
-     *
-     * @param player the player from whom to get the config.
-     * @return the config object
+     * BauGui item id to inventory slot
      */
-    public YAPIONObject get(Player player) {
-        UUID uuid = player.getUniqueId();
-        if (!playerConfigurations.containsKey(uuid)) {
-            String s = UserConfig.getConfig(uuid, "bausystem");
-            YAPIONObject yapionObject;
-            if (s == null) {
-                yapionObject = ConfigCreator.createDefaultConfig();
-            } else {
-                yapionObject = YAPIONParser.parse(s);
-            }
-            yapionObject = update(yapionObject);
-            playerConfigurations.put(uuid, yapionObject);
-            return yapionObject;
-        }
-        return playerConfigurations.get(uuid);
-    }
-
-    public void saveAll() {
-        playerConfigurations.forEach((uuid, yapionObject) -> {
-            String string = yapionObject.toYAPION(new StringOutput()).getResult().replaceAll("\\+", "\\");
-            UserConfig.updatePlayerConfig(uuid, "bausystem", string);
-        });
-        playerConfigurations.clear();
-    }
+    protected Map<Integer, Integer> bauGui = defaultBauGui();
+    protected int bauGuiSize = 45;
 
     /**
-     * Save a PlayerConfig, this does not remove the key value mapping from the map.
-     *
-     * @param player the player to save the config.
+     * Slots 0-8 are the hotbar, slots 9-12 the armor contents
      */
-    public void save(Player player) {
-        UUID uuid = player.getUniqueId();
-        if (playerConfigurations.containsKey(uuid)) {
-            YAPIONObject yapionObject = playerConfigurations.get(uuid);
-            String string = yapionObject.toYAPION(new StringOutput()).getResult().replaceAll("\\\\+", "\\\\");
-            UserConfig.updatePlayerConfig(uuid, "bausystem", string);
-        }
-    }
+    protected ItemStack[] hotbar = DefaultHotbar.defaultHotbar();
 
-    private YAPIONObject update(YAPIONObject yapionObject) {
-        int version = yapionObject.getPlainValue("@version");
-        while (version < ConfigCreator.currentVersion) {
-            ConfigConverter configConverter = CONFIG_CONVERTER_MAP.getOrDefault(version, null);
-            if (configConverter == null) {
-                Bukkit.getLogger().log(Level.SEVERE, "No updater found for version " + version);
-                return ConfigCreator.createDefaultConfig();
-            }
-            try {
-                configConverter.update(yapionObject);
-            } catch (Exception e) {
-                Bukkit.getLogger().log(Level.SEVERE, e.getMessage(), e);
-                return ConfigCreator.createDefaultConfig();
-            }
-            int newVersion = yapionObject.getPlainValue("@version");
-            if (version == newVersion) {
-                Bukkit.getLogger().log(Level.SEVERE, "Version Tag was the same after conversion");
-                return ConfigCreator.createDefaultConfig();
-            }
-            if (newVersion < version) {
-                Bukkit.getLogger().log(Level.SEVERE, "Version Tag was earlier after conversion");
-                return ConfigCreator.createDefaultConfig();
-            }
-            version = newVersion;
-        }
-        return yapionObject;
+    protected boolean nightVision = false;
+    protected boolean tntClickDetails = true;
+    protected boolean detonatorAutostart = false;
+    protected boolean inventoryFill = false;
+    protected boolean rayVisualizer = false;
+    protected boolean smartPlace = false;
+    protected boolean blockCounter = false;
+    protected boolean depthMessage = true;
+
+    public static Map<Integer, Integer> defaultBauGui() {
+        //  0:  ? |  1:  ? |  2: 10 |  3:  3 |  4:  7 |  5: 17 |  6: 15 |  7:  ? |  8:  ?
+        //  9:  5 | 10:  ? | 11:  ? | 12:  ? | 13:  ? | 14:  ? | 15:  ? | 16:  ? | 17: 16
+        // 18:  4 | 19:  ? | 20: 19 | 21: 21 | 22:  9 | 23:  0 | 24:  1 | 25:  ? | 26: 11
+        // 27:  6 | 28:  ? | 29:  ? | 30:  ? | 31:  ? | 32:  ? | 33:  ? | 34:  ? | 35: 18
+        // 36:  ? | 37: 23 | 38: 20 | 39:  8 | 40: 22 | 41: 26 | 42: 12 | 43: 14 | 44:  ?
+        Map<Integer, Integer> bauGui = new HashMap<>();
+        bauGui.put(10, 2); bauGui.put(3, 3); bauGui.put(7, 4); bauGui.put(17, 5); bauGui.put(15, 6);
+        bauGui.put(5, 9); bauGui.put(4, 18); bauGui.put(6, 27);
+        bauGui.put(16, 17); bauGui.put(11, 26); bauGui.put(18, 35);
+        bauGui.put(19, 20); bauGui.put(21, 21); bauGui.put(9, 22); bauGui.put(0, 23); bauGui.put(1, 24);
+        bauGui.put(23, 37); bauGui.put(20, 38); bauGui.put(8, 39); bauGui.put(22, 40); bauGui.put(26, 41); bauGui.put(12, 42); bauGui.put(14, 43);
+        return bauGui;
     }
 }

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

@@ -1,56 +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.configplayer;
-
-import yapion.hierarchy.types.YAPIONObject;
-
-/**
- * A new {@link ConfigConverter} should be written when you remove anything
- * from the Config or modify any mayor part. When you move anything from
- * any key to any other key you should write a new {@link ConfigConverter}.
- * For adding any new key you should be able to get the default without
- * having it in the Config. Anything you need to change you should also
- * change the {@link ConfigCreator} accordingly, to produce the new Config.
- */
-public interface ConfigConverter {
-
-    /**
-     * This describes the version this Converter can convert from. The version
-     * it should convert to is the version 1 above this number. But this is not
-     * a necessity. In the config Object as parameter given in {@link #update(YAPIONObject)}
-     * you should update the <b>@version</b> variable in the root object to the
-     * new version this converter produced.
-     *
-     * @return the version number
-     */
-    int version();
-
-    /**
-     * This method should update everything needed to go from a lower config
-     * version to a higher. It should update the <b>@version</b> variable
-     * accordingly. Anything else is up the implementation. If anything goes wrong
-     * do not silently exit this method, throw an Exception. The updater Code will
-     * deal with it. Never leave the inputted object in a corrupted state.
-     *
-     * @param config the config object to update
-     */
-    void update(YAPIONObject config);
-
-}

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

@@ -1,61 +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.configplayer;
-
-import de.steamwar.bausystem.features.hotbar.DefaultHotbar;
-import lombok.experimental.UtilityClass;
-import yapion.hierarchy.types.YAPIONObject;
-
-@UtilityClass
-public class ConfigCreator {
-
-    public static final int currentVersion = 1;
-
-    public YAPIONObject createDefaultConfig() {
-        YAPIONObject yapionObject = new YAPIONObject();
-        // This call should never be touched
-        yapionObject.add("@version", currentVersion);
-
-        // Any initialising goes into here
-        yapionObject.add("baugui", defaultBauGui());
-
-        // Default Hotbar Gui
-        yapionObject.add("hotbar", DefaultHotbar.defaultHotbar());
-        return yapionObject;
-    }
-
-    private YAPIONObject defaultBauGui() {
-        YAPIONObject yapionObject = new YAPIONObject();
-
-        //  0:  ? |  1:  ? |  2: 10 |  3:  3 |  4:  7 |  5: 17 |  6: 15 |  7:  ? |  8:  ?
-        //  9:  5 | 10:  ? | 11:  ? | 12:  ? | 13:  ? | 14:  ? | 15:  ? | 16:  ? | 17: 16
-        // 18:  4 | 19:  ? | 20: 19 | 21: 21 | 22:  9 | 23:  0 | 24:  1 | 25:  ? | 26: 11
-        // 27:  6 | 28:  ? | 29:  ? | 30:  ? | 31:  ? | 32:  ? | 33:  ? | 34:  ? | 35: 18
-        // 36:  ? | 37: 23 | 38: 20 | 39:  8 | 40: 22 | 41: 26 | 42: 12 | 43: 14 | 44:  ?
-
-        yapionObject.add("10", 2).add("3", 3).add("7", 4).add("17", 5).add("15", 6);
-        yapionObject.add("5", 9).add("4", 18).add("6", 27);
-        yapionObject.add("16", 17).add("11", 26).add("18", 35);
-        yapionObject.add("19", 20).add("21", 21).add("9", 22).add("0", 23).add("1", 24);
-        yapionObject.add("23", 37).add("20", 38).add("8", 39).add("22", 40).add("26", 41).add("12", 42).add("14", 43);
-        yapionObject.add("size", 45);
-        return yapionObject;
-    }
-}

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

@@ -0,0 +1,104 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.configplayer;
+
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.config.legacy.YapionReader;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * The legacy config that was stored in the YAPION format.
+ */
+@Getter
+@Setter
+public class ConfigV1 implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * BauGui item id to inventory slot
+     */
+    protected Map<Integer, Integer> bauGui = new HashMap<>();
+    protected int bauGuiSize = 45;
+
+    /**
+     * Minecraft version to the hotbar serialized by YAPION, read with {@link YapionReader}.
+     * Use {@link de.steamwar.bausystem.config.legacy.YapionItemDeserializer} to get the items.
+     */
+    protected Map<Integer, List<?>> hotbars = new HashMap<>();
+
+    protected boolean nightVision = false;
+    protected boolean tntClickDetails = true;
+    protected boolean detonatorAutostart = false;
+    protected boolean inventoryFill = false;
+    protected boolean rayVisualizer = false;
+    protected boolean smartPlace = false;
+    protected boolean blockCounter = false;
+    protected boolean depthMessage = true;
+
+    public static ConfigV1 parse(String yapion) {
+        Map<String, Object> object = YapionReader.parse(yapion);
+        ConfigV1 config = new ConfigV1();
+        config.version = (Integer) object.get("@version");
+
+        if (object.get("baugui") instanceof Map<?, ?> bauGui) {
+            bauGui.forEach((key, value) -> {
+                if (key.equals("size")) {
+                    config.bauGuiSize = (Integer) value;
+                } else {
+                    config.bauGui.put(Integer.parseInt((String) key), (Integer) value);
+                }
+            });
+        }
+
+        object.forEach((key, value) -> {
+            if (!(value instanceof List<?> hotbar)) return;
+            if (key.equals("hotbar")) {
+                // Hotbars were stored without version prior to 1.19
+                config.hotbars.putIfAbsent(19, hotbar);
+            } else if (key.startsWith("hotbar-")) {
+                config.hotbars.put(Integer.parseInt(key.substring("hotbar-".length())), hotbar);
+            }
+        });
+
+        config.nightVision = getBoolean(object, "nightvision", config.nightVision);
+        config.tntClickDetails = getBoolean(object, "tnt_click_details", config.tntClickDetails);
+        config.detonatorAutostart = getBoolean(object, "detonator-autostart", config.detonatorAutostart);
+        config.inventoryFill = getBoolean(object, "inventoryfill", config.inventoryFill);
+        config.rayVisualizer = getBoolean(object, "rayvisualizer", config.rayVisualizer);
+        config.smartPlace = getBoolean(object, "smartPlace", config.smartPlace);
+        config.blockCounter = getBoolean(object, "blockCounter", config.blockCounter);
+        config.depthMessage = getBoolean(object, "depth_message", config.depthMessage);
+        return config;
+    }
+
+    private static boolean getBoolean(Map<String, Object> object, String key, boolean defaultValue) {
+        return object.get(key) instanceof Boolean value ? value : defaultValue;
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/configplayer/converter/ConfigV1ToV2Converter.java

@@ -0,0 +1,75 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.configplayer.converter;
+
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.config.legacy.YapionItemDeserializer;
+import de.steamwar.bausystem.configplayer.Config;
+import de.steamwar.bausystem.configplayer.ConfigV1;
+import de.steamwar.core.Core;
+import org.bukkit.Bukkit;
+import org.bukkit.inventory.ItemStack;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.logging.Level;
+
+@Deprecated
+public class ConfigV1ToV2Converter implements ConfigConverter<ConfigV1, Config> {
+
+    @Override
+    public int version() {
+        return ConfigV1.VERSION;
+    }
+
+    @Override
+    public Config convert(ConfigV1 old) {
+        Config config = new Config();
+        config.setBauGui(new HashMap<>(old.getBauGui()));
+        config.setBauGuiSize(old.getBauGuiSize());
+
+        List<?> hotbar = old.getHotbars().get(Core.getVersion());
+        if (hotbar != null) {
+            config.setHotbar(convertHotbar(hotbar));
+        }
+
+        config.setNightVision(old.isNightVision());
+        config.setTntClickDetails(old.isTntClickDetails());
+        config.setDetonatorAutostart(old.isDetonatorAutostart());
+        config.setInventoryFill(old.isInventoryFill());
+        config.setRayVisualizer(old.isRayVisualizer());
+        config.setSmartPlace(old.isSmartPlace());
+        config.setBlockCounter(old.isBlockCounter());
+        config.setDepthMessage(old.isDepthMessage());
+        return config;
+    }
+
+    private ItemStack[] convertHotbar(List<?> hotbar) {
+        ItemStack[] items = new ItemStack[13];
+        for (int i = 0; i < Math.min(hotbar.size(), items.length); i++) {
+            try {
+                items[i] = YapionItemDeserializer.deserializeItem(hotbar.get(i));
+            } catch (Exception e) {
+                Bukkit.getLogger().log(Level.WARNING, "Could not convert hotbar item " + i, e);
+            }
+        }
+        return items;
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/configplayer/serializer/ConfigurationSerializableSerializer.java

@@ -1,90 +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.configplayer.serializer;
-
-import org.bukkit.configuration.serialization.ConfigurationSerializable;
-import org.bukkit.configuration.serialization.ConfigurationSerialization;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.ItemMeta;
-import yapion.hierarchy.api.groups.YAPIONAnyType;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.serializing.api.SerializerObject;
-import yapion.serializing.data.DeserializeData;
-import yapion.serializing.data.SerializeData;
-
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.Map;
-
-import static yapion.utils.IdentifierUtils.TYPE_IDENTIFIER;
-
-public class ConfigurationSerializableSerializer extends SerializerObject<ConfigurationSerializable> {
-
-    @Override
-    public Class<ConfigurationSerializable> type() {
-        return ConfigurationSerializable.class;
-    }
-
-    @Override
-    public boolean isInterface() {
-        return true;
-    }
-
-    @Override
-    public YAPIONObject serialize(SerializeData<ConfigurationSerializable> serializeData) {
-        YAPIONObject yapionObject = new YAPIONObject();
-        yapionObject.add(TYPE_IDENTIFIER, serializeData.object.getClass().getTypeName());
-        if (serializeData.object instanceof ItemStack) {
-            yapionObject.add(TYPE_IDENTIFIER, ItemStack.class.getTypeName());
-        }
-        if (serializeData.object instanceof ItemMeta) {
-            yapionObject.add(TYPE_IDENTIFIER, ItemMeta.class.getTypeName());
-        }
-        Map<String, Object> serializeDataMap = serializeData.object.serialize();
-        serializeDataMap.forEach((s, o) -> {
-            YAPIONAnyType yapionAnyType = serializeData.serialize(o);
-            if (yapionAnyType instanceof YAPIONObject) {
-                YAPIONObject object = (YAPIONObject) yapionAnyType;
-                if (object.containsKey(TYPE_IDENTIFIER) && object.getPlainValue(TYPE_IDENTIFIER).equals("com.google.common.collect.RegularImmutableList")) {
-                    object.put(TYPE_IDENTIFIER, ArrayList.class.getTypeName());
-                }
-            }
-            yapionObject.add(s, yapionAnyType);
-        });
-        return yapionObject;
-    }
-
-    @Override
-    public ConfigurationSerializable deserialize(DeserializeData<YAPIONObject> deserializeData) {
-        Map<String, Object> deserializeDataMap = new HashMap<>();
-        deserializeData.object.forEach((s, yapionAnyType) -> {
-            if (s.equals(TYPE_IDENTIFIER)) {
-                if (yapionAnyType.toString().equals("(org.bukkit.inventory.meta.ItemMeta)")) {
-                    deserializeDataMap.put("==", "ItemMeta");
-                } else {
-                    deserializeDataMap.put("==", deserializeData.deserialize(yapionAnyType));
-                }
-                return;
-            }
-            deserializeDataMap.put(s, deserializeData.deserialize(yapionAnyType));
-        });
-        return ConfigurationSerialization.deserializeObject(deserializeDataMap);
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/cannon/depth/Depth.java

@@ -64,7 +64,7 @@ public class Depth {
         dimensions.setZ(Math.abs(dimensions.getZ()));
 
         RegionUtils.message(region, player -> {
-            if (Config.getInstance().get(player).getPlainValueOrDefault("depth_message", true)) {
+            if (Config.STORE.get(player).isDepthMessage()) {
                 player.spigot().sendMessage(getMessage(player, dimensions.getBlockX() + 1, dimensions.getBlockY() + 1, dimensions.getBlockZ() + 1, tntCount));
             }
         });

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/cannon/depth/DepthCommand.java

@@ -34,11 +34,11 @@ public class DepthCommand extends SWCommand {
 
     @Register
     public void toggle(Player player) {
-        if (Config.getInstance().get(player).getPlainValueOrDefault("depth_message", true)) {
-            Config.getInstance().get(player).put("depth_message", false);
+        if (Config.STORE.get(player).isDepthMessage()) {
+            Config.STORE.get(player).setDepthMessage(false);
             BauSystem.MESSAGE.send("DEPTH_COUNTER_DISABLE", player);
         } else {
-            Config.getInstance().get(player).put("depth_message", true);
+            Config.STORE.get(player).setDepthMessage(true);
             BauSystem.MESSAGE.send("DEPTH_COUNTER_ENABLE", player);
         }
     }

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

@@ -95,7 +95,7 @@ public class Detonator {
 
     public static void activateDetonator(DetonatorStorage detonator) {
         Player p = detonator.getPlayer();
-        if (Config.getInstance().get(p).getPlainValueOrDefault("detonator-autostart", false)) {
+        if (Config.STORE.get(p).isDetonatorAutostart()) {
             AutostartListener.instance.activate(p);
         }
 

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

@@ -76,8 +76,8 @@ public class DetonatorCommand extends SWCommand {
 
     @Register(value = "autostart", description = "DETONATOR_HELP_AUTOSTART")
     public void toggleAutostartTimer(Player p) {
-        boolean current = Config.getInstance().get(p).getPlainValueOrDefault("detonator-autostart", false);
-        Config.getInstance().get(p).put("detonator-autostart", !current);
+        boolean current = Config.STORE.get(p).isDetonatorAutostart();
+        Config.STORE.get(p).setDetonatorAutostart(!current);
         if (!current) {
             BauSystem.MESSAGE.send("DETONATOR_AUTOSTART_ENABLE", p);
         } else {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/gui/editor/BauGuiMapping.java

@@ -28,7 +28,6 @@ import lombok.Setter;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitTask;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.*;
 
@@ -52,15 +51,15 @@ public class BauGuiMapping {
     }
 
     @Getter
-    private final YAPIONObject object;
+    private final Config config;
     @Getter
     private final Player owner;
     @Getter
     @Setter
     private boolean saved;
 
-    protected BauGuiMapping(YAPIONObject object, Player p) {
-        this.object = object;
+    protected BauGuiMapping(Config config, Player p) {
+        this.config = config;
         this.owner = p;
         fromUUID.put(p.getUniqueId(), this);
         mappings.add(this);
@@ -70,19 +69,18 @@ public class BauGuiMapping {
         BauGuiMapping mapping = fromUUID.get(p.getUniqueId());
 
         if (mapping == null) {
-            YAPIONObject yapionObject = Config.getInstance().get(p);
-            mapping = new BauGuiMapping(yapionObject.getObject("baugui"), p);
+            mapping = new BauGuiMapping(Config.STORE.get(p), p);
         }
 
         return mapping;
     }
 
     public boolean isShown(int id) {
-        return object.getPlainValueOrDefault(Integer.toString(id), -1) >= 0;
+        return config.getBauGui().getOrDefault(id, -1) >= 0;
     }
 
     public int getSlot(int id) {
-        return object.getPlainValue(Integer.toString(id));
+        return config.getBauGui().get(id);
     }
 
     public Map<Integer, Integer> getMapping() {
@@ -94,7 +92,7 @@ public class BauGuiMapping {
     }
 
     public int getSize() {
-        return object.getPlainValueOrDefault("size", 45);
+        return config.getBauGuiSize();
     }
 
     public void setSize(int size) {
@@ -102,7 +100,7 @@ public class BauGuiMapping {
             return;
         }
 
-        object.add("size", size);
+        config.setBauGuiSize(size);
     }
 
     private void tick() {
@@ -111,16 +109,17 @@ public class BauGuiMapping {
 
     public void save() {
         if (saved) return;
-        YAPIONObject config = Config.getInstance().get(owner);
-        config.add("baugui", object);
-        Config.getInstance().save(owner);
+        Config current = Config.STORE.get(owner);
+        current.setBauGui(config.getBauGui());
+        current.setBauGuiSize(config.getBauGuiSize());
+        Config.STORE.save(owner);
         saved = true;
     }
 
     private Map<Integer, Integer> internalReadMap() {
         Map<Integer, Integer> map = new HashMap<>();
         for (Map.Entry<Integer, BauGuiItem> e : BauGUI.getITEMS().entrySet()) {
-            Integer value = object.getPlainValueOrDefault(e.getKey().toString(), -1);
+            Integer value = config.getBauGui().getOrDefault(e.getKey(), -1);
             if (value == -1) continue;
             map.put(e.getKey(), value);
         }
@@ -129,10 +128,10 @@ public class BauGuiMapping {
 
     private void internalWriteMap(Map<Integer, Integer> map) {
         for (Map.Entry<Integer, BauGuiItem> e : BauGUI.getITEMS().entrySet()) {
-            object.remove(e.getKey().toString());
+            config.getBauGui().remove(e.getKey());
             Integer value = map.getOrDefault(e.getKey(), -1);
             if (value == -1) continue;
-            object.add(e.getKey().toString(), value);
+            config.getBauGui().put(e.getKey(), value);
         }
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/hotbar/DefaultHotbar.java

@@ -20,39 +20,23 @@
 package de.steamwar.bausystem.features.hotbar;
 
 import de.steamwar.bausystem.configplayer.Config;
-import de.steamwar.core.Core;
 import lombok.experimental.UtilityClass;
+import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.inventory.ItemStack;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.hierarchy.types.YAPIONValue;
-import yapion.parser.YAPIONParser;
-import yapion.serializing.YAPIONDeserializer;
-import yapion.serializing.YAPIONSerializer;
+import org.bukkit.inventory.meta.ItemMeta;
 
-import java.util.HashSet;
-import java.util.Set;
+import java.util.List;
 
 @UtilityClass
 public class DefaultHotbar {
 
-    private final YAPIONArray DEFAULT_HOTBAR = YAPIONParser.parse("{[{@type(org.bukkit.inventory.ItemStack)v(2230)type(WOODEN_AXE)meta{@type(org.bukkit.inventory.meta.ItemMeta)meta-type(UNSPECIFIC)display-name(WorldEdit Wand)lore{@type(java.util.ArrayList)values[Left click: select pos #1,Right click: select pos #2]}}},{@type(org.bukkit.inventory.ItemStack)v(2230)type(COMPASS)meta{@type(org.bukkit.inventory.meta.ItemMeta)meta-type(UNSPECIFIC)display-name(Navigation Wand)lore{@type(java.util.ArrayList)values[Left click: jump to location,Right click: pass through walls]}}},null,null,null,null,null,null,{@type(org.bukkit.inventory.ItemStack)v(2230)type(NETHER_STAR)meta{@type(org.bukkit.inventory.meta.ItemMeta)meta-type(UNSPECIFIC)display-name(§eBau GUI)}},null,null,{@type(org.bukkit.inventory.ItemStack)v(3117)type(ELYTRA)},null]}").getArray("");
-
     public void updateHotbar(Player p) {
         ItemStack[] hotbar = new ItemStack[13];
         System.arraycopy(p.getInventory().getContents(), 0, hotbar, 0, 9);
         System.arraycopy(p.getInventory().getArmorContents(), 0, hotbar, 9, 4);
-        YAPIONArray yapionArray = new YAPIONArray();
-        for (ItemStack itemStack : hotbar) {
-            if (itemStack != null) {
-                yapionArray.add(YAPIONSerializer.serialize(itemStack));
-            } else {
-                yapionArray.add(new YAPIONValue<>(null));
-            }
-        }
-        Config.getInstance().get(p).add("hotbar-" + Core.getVersion(), yapionArray);
-        Config.getInstance().save(p);
+        Config.STORE.get(p).setHotbar(copy(hotbar));
+        Config.STORE.save(p);
     }
 
     public void setHotbar(Player p) {
@@ -66,28 +50,34 @@ public class DefaultHotbar {
     }
 
     public ItemStack[] getItems(Player p) {
-        Config.getInstance().get(p).remap("hotbar", "hotbar-19");
-        YAPIONArray yapionArray = Config.getInstance().get(p).getYAPIONArrayOrSetDefault("hotbar-" + Core.getVersion(), defaultHotbar());
+        return copy(Config.STORE.get(p).getHotbar());
+    }
+
+    public ItemStack[] defaultHotbar() {
         ItemStack[] hotbar = new ItemStack[13];
-        Set<Integer> invalid = new HashSet<>();
-        yapionArray.forEach((integer, yapionAnyType) -> {
-            if (yapionAnyType instanceof YAPIONValue) {
-                hotbar[integer] = null;
-            } else {
-                try {
-                    hotbar[integer] = YAPIONDeserializer.deserialize((YAPIONObject) yapionAnyType);
-                } catch (Exception e) {
-                    invalid.add(integer);
-                    hotbar[integer] = null;
-                }
-            }
-        });
-        invalid.forEach(i -> yapionArray.set(i, new YAPIONValue<>(null)));
-        if (!invalid.isEmpty()) Config.getInstance().save(p);
+        hotbar[0] = item(Material.WOODEN_AXE, "WorldEdit Wand", "Left click: select pos #1", "Right click: select pos #2");
+        hotbar[1] = item(Material.COMPASS, "Navigation Wand", "Left click: jump to location", "Right click: pass through walls");
+        hotbar[8] = item(Material.NETHER_STAR, "§eBau GUI");
+        hotbar[11] = new ItemStack(Material.ELYTRA);
         return hotbar;
     }
 
-    public YAPIONArray defaultHotbar() {
-        return DEFAULT_HOTBAR;
+    private ItemStack item(Material material, String name, String... lore) {
+        ItemStack itemStack = new ItemStack(material);
+        ItemMeta meta = itemStack.getItemMeta();
+        meta.setDisplayName(name);
+        if (lore.length > 0) {
+            meta.setLore(List.of(lore));
+        }
+        itemStack.setItemMeta(meta);
+        return itemStack;
+    }
+
+    private ItemStack[] copy(ItemStack[] hotbar) {
+        ItemStack[] copy = new ItemStack[13];
+        for (int i = 0; i < Math.min(hotbar.length, copy.length); i++) {
+            copy[i] = hotbar[i] == null ? null : hotbar[i].clone();
+        }
+        return copy;
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/hullhider/HullHiderCommand.java

@@ -0,0 +1,177 @@
+/*
+ *   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.hullhider;
+
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.bausystem.features.techhider.HiddenHull;
+import de.steamwar.bausystem.features.techhider.HidingRule;
+import de.steamwar.bausystem.features.techhider.TechHiderCommand;
+import de.steamwar.bausystem.features.xray.XrayCommand;
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.command.SWCommand;
+import de.steamwar.hullhider.Hull;
+import de.steamwar.hullhider.HullHider;
+import de.steamwar.hullhider.HullRegion;
+import de.steamwar.hullhider.Viewers;
+import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.linkage.LinkedTimer;
+import de.steamwar.techhider.ObfuscationConfig;
+import net.md_5.bungee.api.ChatMessageType;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerQuitEvent;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * Hides the inside of the build area hull of a region from the players who toggle it, as the hull hider of a fight would.
+ */
+@Linked
+public class HullHiderCommand extends SWCommand implements Listener {
+
+    public HullHiderCommand() {
+        super("hullhider");
+    }
+
+    @Linked
+    // Only blocks are hidden, entities stay visible
+    private final HullHider<Region> hullHider = new HullHider<>(false);
+    // Read on netty threads by the BauTechHider
+    private final Map<Region, HiddenHull> hulls = new ConcurrentHashMap<>();
+    private final Map<Region, HidingRule> hidingRules = new ConcurrentHashMap<>();
+    private final Map<Region, Set<Player>> hidden = new ConcurrentHashMap<>();
+
+    @LinkedInstance
+    public TechHiderCommand techHiderCommand;
+
+    @LinkedInstance
+    public XrayCommand xrayCommand;
+
+    @Register(description = "HULLHIDER_HELP")
+    public void toggleHider(@Validator Player player) {
+        Region region = Region.getRegion(player.getLocation());
+        if (region.getType().isGlobal()) {
+            BauSystem.MESSAGE.send("HULLHIDER_GLOBAL", player);
+            return;
+        }
+        if (!region.getGameModeConfig().Techhider.Active) {
+            return;
+        }
+
+        techHiderCommand.disable(region, player);
+        xrayCommand.disable(region, player);
+        if (hidden.getOrDefault(region, Collections.emptySet()).contains(player)) {
+            disable(region, player);
+            BauSystem.MESSAGE.sendPrefixless("HULLHIDER_OFF", player, ChatMessageType.ACTION_BAR);
+        } else {
+            enable(region, player);
+            BauSystem.MESSAGE.sendPrefixless("HULLHIDER_ON", player, ChatMessageType.ACTION_BAR);
+        }
+    }
+
+    private void enable(Region region, Player player) {
+        if (!hulls.containsKey(region)) {
+            Point min = region.getBuildArea().getMinPoint(true);
+            Point max = region.getBuildArea().getMaxPoint(true);
+            HullRegion hullRegion = HullRegion.fromInclusive(min.getX(), min.getY(), min.getZ(), max.getX(), max.getY(), max.getZ());
+
+            // The techhider of the gamemode is applied as well, its hidden blocks occlude as they are replaced by the obfuscation block
+            ObfuscationConfig obfuscation = ObfuscationConfig.of(region.getGameModeConfig().Techhider);
+            Hull hull = new Hull(BauSystem.getInstance(), world(), hullRegion, false, obfuscation, new Viewers.VisibleByDefault());
+            hullHider.addHull(region, hull);
+            hulls.put(region, new HiddenHull(hull, obfuscation.getObfuscationState()));
+            hidingRules.put(region, HidingRule.of(region.getBuildArea(), obfuscation));
+        }
+
+        hidden.computeIfAbsent(region, rg -> ConcurrentHashMap.newKeySet()).add(player);
+        // Added players see the hull blocks of a hull visible by default
+        hullHider.addViewer(player, region);
+        // Block changes by WorldEdit or Axiom do not update the hull, so it is rebuilt every time somebody enables it.
+        // This also resends the chunks to the player.
+        hullHider.initialize(region);
+    }
+
+    /**
+     * Stops hiding the hull of the region from the player, removing the hull if nobody uses it anymore.
+     */
+    public void disable(Region region, Player player) {
+        Set<Player> players = hidden.get(region);
+        if (players == null || !players.remove(player)) return;
+
+        if (players.isEmpty()) {
+            hidden.remove(region);
+            hulls.remove(region);
+            hidingRules.remove(region);
+            hullHider.removeHull(region);
+        } else {
+            hullHider.removeViewer(player, region);
+            hullHider.resendChunks(player, region);
+        }
+    }
+
+    public void addHidingRules(Player player, List<HidingRule> rules) {
+        hidden.forEach((region, players) -> {
+            HidingRule rule = hidingRules.get(region);
+            if (rule != null && players.contains(player)) {
+                rules.add(rule);
+            }
+        });
+    }
+
+    public void addHiddenHulls(Player player, List<HiddenHull> hiddenHulls) {
+        hidden.forEach((region, players) -> {
+            HiddenHull hiddenHull = hulls.get(region);
+            if (hiddenHull != null && players.contains(player)) {
+                hiddenHulls.add(hiddenHull);
+            }
+        });
+    }
+
+    @LinkedTimer(delay = 1, period = 1)
+    private void onTick() {
+        if (hidden.isEmpty()) return;
+
+        hullHider.sendUncoveredBlocks();
+    }
+
+    private World world() {
+        return Bukkit.getWorlds().get(0);
+    }
+
+    @EventHandler
+    public void onPlayerQuit(PlayerQuitEvent event) {
+        for (Region region : hidden.keySet()) {
+            disable(region, event.getPlayer());
+        }
+    }
+
+    public boolean isActive(Region region, Player player) {
+        return hidden.getOrDefault(region, Collections.emptySet()).contains(player);
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/inventoryfiller/InventoryFillBauGuiItem.java

@@ -49,7 +49,7 @@ public class InventoryFillBauGuiItem extends BauGuiItem {
 
     @Override
     public ItemStack getItem(Player player) {
-        String loreKey = Config.getInstance().get(player).getPlainValueOrDefault("inventoryfill", false) ? "OTHER_ITEMS_INVENTORY_FILL_LORE_ACTIVE" : "OTHER_ITEMS_INVENTORY_FILL_LORE_INACTIVE";
+        String loreKey = Config.STORE.get(player).isInventoryFill() ? "OTHER_ITEMS_INVENTORY_FILL_LORE_ACTIVE" : "OTHER_ITEMS_INVENTORY_FILL_LORE_INACTIVE";
         return new SWItem(Material.HOPPER, BauSystem.MESSAGE.parse("OTHER_ITEMS_INVENTORY_FILL_NAME", player), Collections.singletonList(BauSystem.MESSAGE.parse(loreKey, player)), false, clickType -> {
         }).getItemStack();
     }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/inventoryfiller/InventoryFiller.java

@@ -40,7 +40,7 @@ public class InventoryFiller implements Listener {
     @EventHandler
     public void onPlayerDropItem(PlayerDropItemEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("inventoryfill", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isInventoryFill()) return;
         if (!event.getPlayer().isSneaking()) return;
         Block block = event.getPlayer().getTargetBlockExact(5);
         if (block == null) return;
@@ -62,7 +62,7 @@ public class InventoryFiller implements Listener {
     @EventHandler
     public void onPlayerItemHeld(PlayerItemHeldEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("inventoryfill", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isInventoryFill()) return;
         if (!event.getPlayer().isSneaking()) return;
         ItemStack itemStack = event.getPlayer().getInventory().getItemInMainHand();
         if (itemStack.getType() == Material.AIR) return;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/inventoryfiller/InventoryFillerCommand.java

@@ -68,8 +68,8 @@ public class InventoryFillerCommand extends SWCommand {
 
     @Register(description = {"INVENTORY_FILL_HELP", "INVENTORY_FILL_INFO"})
     public void toggle(Player player) {
-        boolean inventoryFill = Config.getInstance().get(player).getPlainValueOrDefault("inventoryfill", false);
-        Config.getInstance().get(player).put("inventoryfill", !inventoryFill);
+        boolean inventoryFill = Config.STORE.get(player).isInventoryFill();
+        Config.STORE.get(player).setInventoryFill(!inventoryFill);
         if (!inventoryFill) {
             SWUtils.sendToActionbar(player, BauSystem.MESSAGE.parse("INVENTORY_FILL_ENABLE", player));
             BauSystem.MESSAGE.send("INVENTORY_FILL_INFO", player);

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/loader/Loader.java

@@ -36,9 +36,11 @@ import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
 import org.bukkit.event.Listener;
 import org.bukkit.event.inventory.ClickType;
 import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.scheduler.BukkitTask;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -63,13 +65,14 @@ public class Loader implements Listener, SWPlayer.Component {
     private List<LoaderElement> elements = new ArrayList<>();
     private int currentElement = 0;
     private long waitTime = 0;
+    private final BukkitTask task;
 
     public Loader(Player p) {
         this.p = p;
         this.recorder = new LoaderRecorder(p, elements);
         Bukkit.getPluginManager().registerEvents(this, BauSystem.getInstance());
 
-        BauSystem.runTaskTimer(BauSystem.getInstance(), () -> {
+        task = BauSystem.runTaskTimer(BauSystem.getInstance(), () -> {
             if (stage != Stage.RUNNING && stage != Stage.SINGLE) return;
             if (!Permission.BUILD.hasPermission(p)) return;
             if (waitTime > 0) {
@@ -136,13 +139,27 @@ public class Loader implements Listener, SWPlayer.Component {
     }
 
     public void stop() {
+        end();
+        if (getLoader(p) == this) {
+            SWPlayer.of(p).removeComponent(Loader.class);
+        }
+    }
+
+    // Also called when the loader is replaced by a new one
+    @Override
+    public void onUnmount(SWPlayer player) {
+        end();
+    }
+
+    private void end() {
         stage = Stage.END;
         if (recorder != null) {
             recorder.stop();
             recorder = null;
         }
         elements.clear();
-        SWPlayer.of(p).removeComponent(Loader.class);
+        task.cancel();
+        HandlerList.unregisterAll(this);
     }
 
     public boolean setTicksBetweenShots(int delay) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/observer/ObserverTracerListener.java

@@ -24,6 +24,7 @@ import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedTimer;
 import org.bukkit.Bukkit;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
@@ -43,13 +44,12 @@ public class ObserverTracerListener implements Listener {
 
     static Set<Player> enabled = new HashSet<>();
 
-    public ObserverTracerListener() {
-        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
-            SWPlayer.allWithSingleComponent(ObserverTracer.class).forEach(pair -> {
-                if (pair.getSwPlayer().getPlayer().getGameMode() != GameMode.SPECTATOR) return;
-                pair.getComponent().show();
-            });
-        }, 15L, 15L);
+    @LinkedTimer(delay = 15, period = 15)
+    private void showTracers() {
+        SWPlayer.allWithSingleComponent(ObserverTracer.class).forEach(pair -> {
+            if (pair.getSwPlayer().getPlayer().getGameMode() != GameMode.SPECTATOR) return;
+            pair.getComponent().show();
+        });
     }
 
     @EventHandler

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/rayvisualizer/RayVisualizerCommand.java

@@ -28,6 +28,7 @@ import de.steamwar.command.SWCommand;
 import de.steamwar.entity.CRay;
 import de.steamwar.entity.REntityServer;
 import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedTimer;
 import org.bukkit.*;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.entity.Player;
@@ -104,15 +105,16 @@ public class RayVisualizerCommand extends SWCommand implements Listener {
 
     public RayVisualizerCommand() {
         super("rayvisualizer");
+    }
 
-        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
-            if (server.getPlayers().isEmpty()) return;
-            List<TNTPrimed> primedList = WORLD.getEntitiesByClass(TNTPrimed.class)
-                    .stream().toList();
-            rayData.reset();
-            if (primedList.isEmpty()) return;
-            calculateRays(primedList, primedList);
-        }, 1, 1);
+    @LinkedTimer(delay = 1, period = 1)
+    private void updateRays() {
+        if (server.getPlayers().isEmpty()) return;
+        List<TNTPrimed> primedList = WORLD.getEntitiesByClass(TNTPrimed.class)
+                .stream().toList();
+        rayData.reset();
+        if (primedList.isEmpty()) return;
+        calculateRays(primedList, primedList);
     }
 
     private void calculateRays(List<TNTPrimed> fromTNTs, List<TNTPrimed> toTNTs) {
@@ -167,7 +169,7 @@ public class RayVisualizerCommand extends SWCommand implements Listener {
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        boolean rayvisualizer = Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("rayvisualizer", false);
+        boolean rayvisualizer = Config.STORE.get(event.getPlayer()).isRayVisualizer();
         if (rayvisualizer) server.addPlayer(event.getPlayer());
     }
 
@@ -181,7 +183,7 @@ public class RayVisualizerCommand extends SWCommand implements Listener {
         Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
             for (Player player : Bukkit.getOnlinePlayers()) {
                 if (Permission.BUILD.hasPermission(player)) {
-                    boolean rayvisualizer = Config.getInstance().get(player).getPlainValueOrDefault("rayvisualizer", false);
+                    boolean rayvisualizer = Config.STORE.get(player).isRayVisualizer();
                     if (rayvisualizer) server.addPlayer(player);
                 } else {
                     server.removePlayer(player);
@@ -192,8 +194,8 @@ public class RayVisualizerCommand extends SWCommand implements Listener {
 
     @Register
     public void toggle(@Validator Player player) {
-        boolean rayvisualizer = Config.getInstance().get(player).getPlainValueOrDefault("rayvisualizer", false);
-        Config.getInstance().get(player).put("rayvisualizer", !rayvisualizer);
+        boolean rayvisualizer = Config.STORE.get(player).isRayVisualizer();
+        Config.STORE.get(player).setRayVisualizer(!rayvisualizer);
         if (!rayvisualizer) {
             SWUtils.sendToActionbar(player, BauSystem.MESSAGE.parse("RAY_VISUALIZER_ENABLE", player));
             server.addPlayer(player);

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

@@ -0,0 +1,48 @@
+/*
+ *   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.region;
+
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.RegionUtils;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.ProjectileStopperMode;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+import org.bukkit.entity.Player;
+
+@Linked
+public class ProjectileStopperCommand extends SWCommand {
+
+    public ProjectileStopperCommand() {
+        super("projectilestopper");
+    }
+
+    @Register(description = "REGION_PROJECTILE_STOPPER_HELP")
+    public void toggleCommand(@Validator Player p) {
+        Region region = Region.getRegion(p.getLocation());
+        if (region.getRegionData().get(Flag.PROJECTILE_STOPPER).get() == ProjectileStopperMode.ENABLED) {
+            region.getRegionData().set(Flag.PROJECTILE_STOPPER, ProjectileStopperMode.DISABLED);
+            RegionUtils.actionBar(region, "REGION_PROJECTILE_STOPPER_OFF");
+        } else {
+            region.getRegionData().set(Flag.PROJECTILE_STOPPER, ProjectileStopperMode.ENABLED);
+            RegionUtils.actionBar(region, "REGION_PROJECTILE_STOPPER_ON");
+        }
+    }
+}

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

@@ -0,0 +1,88 @@
+/*
+ *   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.region;
+
+import com.destroystokyo.paper.event.server.ServerTickEndEvent;
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.ProjectileStopperMode;
+import de.steamwar.bausystem.utils.ScoreboardElement;
+import de.steamwar.linkage.Linked;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntitySpawnEvent;
+
+import java.util.*;
+
+@Linked
+public class ProjectileStopperListener implements Listener, ScoreboardElement {
+    private Map<Region, Set<Entity>> projektileList = new HashMap<>();
+
+    @EventHandler
+    public void onTick(ServerTickEndEvent event) {
+        List<Entity> entitiesToAdd = new ArrayList<>();
+
+        projektileList.forEach((region, entities) -> {
+            entities.removeIf(entity -> {
+                if (region != Region.getRegion(entity.getLocation())) {
+                    if (region.getRegionData().get(Flag.PROJECTILE_STOPPER).getWithDefault() == ProjectileStopperMode.ENABLED) {
+                        entity.remove();
+                    } else {
+                        entitiesToAdd.add(entity);
+                    }
+                    return true;
+                }
+                return false;
+            });
+        });
+        entitiesToAdd.forEach(this::addEntity);
+    }
+
+    @EventHandler
+    public void onEntitySpawn(EntitySpawnEvent event) {
+        if (event.getEntityType() != EntityType.WIND_CHARGE && event.getEntityType() != EntityType.ARROW && event.getEntityType() != EntityType.SMALL_FIREBALL) return;
+        addEntity(event.getEntity());
+    }
+
+    private void addEntity(Entity entity) {
+        Region region = Region.getRegion(entity.getLocation());
+        projektileList.computeIfAbsent(region, key -> new HashSet<>()).add(entity);
+    }
+
+    @Override
+    public ScoreboardGroup getGroup() {
+        return ScoreboardGroup.REGION;
+    }
+
+    @Override
+    public int order() {
+        return 2;
+    }
+
+    @Override
+    public String get(Region region, Player p) {
+        if (region.getRegionData().get(Flag.PROJECTILE_STOPPER).is(ProjectileStopperMode.ENABLED)) return null;
+        return "§e" + BauSystem.MESSAGE.parse(Flag.PROJECTILE_STOPPER.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.PROJECTILE_STOPPER).getWithDefault().getChatValue(), p);
+    }
+}

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

@@ -28,6 +28,7 @@ import de.steamwar.bausystem.utils.ScoreboardElement;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Location;
 import org.bukkit.block.Block;
+import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
@@ -55,6 +56,7 @@ public class ProtectListener implements Listener, ScoreboardElement {
 
     @EventHandler
     public void onExplode(EntityExplodeEvent event) {
+        if (event.getEntityType() == EntityType.WIND_CHARGE) return;
         explode(event.blockList(), event.getLocation());
     }
 

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

@@ -28,6 +28,7 @@ import de.steamwar.bausystem.utils.ScoreboardElement;
 import de.steamwar.linkage.Linked;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
+import org.bukkit.entity.EntityType;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.TNTPrimed;
 import org.bukkit.event.EventHandler;
@@ -67,6 +68,7 @@ public class TNTListener implements Listener, ScoreboardElement {
 
     @EventHandler(priority = EventPriority.HIGH, ignoreCancelled = true)
     public void onExplode(EntityExplodeEvent event) {
+        if (event.getEntityType() == EntityType.WIND_CHARGE) return;
         explode(event.blockList(), event.getEntity() instanceof TNTPrimed);
     }
 

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

@@ -0,0 +1,48 @@
+/*
+ *   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.region;
+
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.RegionUtils;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.WindChargeInteractMode;
+import de.steamwar.command.SWCommand;
+import de.steamwar.linkage.Linked;
+import org.bukkit.entity.Player;
+
+@Linked
+public class WindChargeInteractModeCommand extends SWCommand {
+
+    public WindChargeInteractModeCommand() {
+        super("windchargeinteract");
+    }
+
+    @Register(description = "REGION_WINDCHARGE_HELP")
+    public void toggleCommand(@Validator Player p) {
+        Region region = Region.getRegion(p.getLocation());
+        if (region.getRegionData().get(Flag.WIND_CHARGE_INTERACT).get() == WindChargeInteractMode.DENY) {
+            region.getRegionData().set(Flag.WIND_CHARGE_INTERACT, WindChargeInteractMode.ALLOW);
+            RegionUtils.actionBar(region, "REGION_WINDCHARGE_INTERACT_ON");
+        } else {
+            region.getRegionData().set(Flag.WIND_CHARGE_INTERACT, WindChargeInteractMode.DENY);
+            RegionUtils.actionBar(region, "REGION_WINDCHARGE_INTERACT_OFF");
+        }
+    }
+}

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

@@ -0,0 +1,59 @@
+/*
+ *   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.region;
+
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.WindChargeInteractMode;
+import de.steamwar.bausystem.utils.ScoreboardElement;
+import de.steamwar.linkage.Linked;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.EntityExplodeEvent;
+
+@Linked
+public class WindChargeInteractModeListener implements Listener, ScoreboardElement {
+
+    @EventHandler
+    public void onExplode(EntityExplodeEvent event) {
+        if (event.getEntityType() != EntityType.WIND_CHARGE) return;
+        Region region = Region.getRegion(event.getLocation());
+        if (region.getRegionData().get(Flag.WIND_CHARGE_INTERACT).getWithDefault() != WindChargeInteractMode.ALLOW) event.blockList().clear();
+    }
+
+    @Override
+    public ScoreboardGroup getGroup() {
+        return ScoreboardGroup.REGION;
+    }
+
+    @Override
+    public int order() {
+        return 2;
+    }
+
+    @Override
+    public String get(Region region, Player p) {
+        if (region.getRegionData().get(Flag.WIND_CHARGE_INTERACT).is(WindChargeInteractMode.ALLOW)) return null;
+        return "§e" + BauSystem.MESSAGE.parse(Flag.WIND_CHARGE_INTERACT.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.WIND_CHARGE_INTERACT).getWithDefault().getChatValue(), p);
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/script/event/EventListener.java

@@ -27,6 +27,7 @@ import de.steamwar.bausystem.features.script.lua.libs.StorageLib;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedTimer;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.entity.EntityType;
@@ -47,13 +48,12 @@ import org.luaj.vm2.LuaValue;
 @Linked
 public class EventListener implements Listener {
 
-    static {
-        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
-            long millis = System.currentTimeMillis();
-            SWPlayer.allWithSingleComponent(ScriptRunner.ScriptData.class)
-                    .filter(pair -> millis - pair.getComponent().getLastF() > 200)
-                    .forEach(pair -> pair.getComponent().setLastF(Long.MAX_VALUE));
-        }, 1, 1);
+    @LinkedTimer(delay = 1, period = 1)
+    private static void resetLastF() {
+        long millis = System.currentTimeMillis();
+        SWPlayer.allWithSingleComponent(ScriptRunner.ScriptData.class)
+                .filter(pair -> millis - pair.getComponent().getLastF() > 200)
+                .forEach(pair -> pair.getComponent().setLastF(Long.MAX_VALUE));
     }
 
     @EventHandler(priority = EventPriority.MONITOR)

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

@@ -44,9 +44,9 @@ import de.steamwar.entity.REntity;
 import de.steamwar.entity.REntityServer;
 import de.steamwar.inventory.SWAnvilInv;
 import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedTimer;
 import lombok.AllArgsConstructor;
 import lombok.Getter;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
@@ -136,11 +136,10 @@ public class SimulatorCursor implements Listener {
 
     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);
+    @LinkedTimer(delay = 1, period = 1)
+    private static void clearLastSneaks() {
+        long millis = System.currentTimeMillis();
+        LAST_SNEAKS.entrySet().removeIf(entry -> millis - entry.getValue() > 200);
     }
 
     @EventHandler(priority = EventPriority.HIGH)

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/data/SimulatorElement.java

@@ -21,6 +21,7 @@ package de.steamwar.bausystem.features.simulator.data;
 
 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import de.steamwar.inventory.InvCallback;
 import de.steamwar.inventory.SWItem;
 import lombok.Getter;
@@ -28,7 +29,6 @@ import lombok.Setter;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.ArrayList;
 import java.util.Comparator;
@@ -121,9 +121,9 @@ public abstract class SimulatorElement<T extends SimulatorPhase> {
 
     public abstract String getType();
 
-    public void saveExtra(YAPIONObject elementObject) {
+    public void saveExtra(SimulatorConfig.Element element) {
     }
 
-    public void loadExtra(YAPIONObject elementObject) {
+    public void loadExtra(SimulatorConfig.Element element) {
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/data/SimulatorPhase.java

@@ -20,10 +20,10 @@
 package de.steamwar.bausystem.features.simulator.data;
 
 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import lombok.Getter;
 import lombok.Setter;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.function.BiConsumer;
 
@@ -38,9 +38,9 @@ public abstract class SimulatorPhase {
 
     public abstract void toSimulatorActions(Vector position, BiConsumer<Integer, SimulatorAction> tickStart, BiConsumer<Integer, SimulatorAction> tickEnd);
 
-    public void saveExtra(YAPIONObject phaseObject) {
+    public void saveExtra(SimulatorConfig.Phase phase) {
     }
 
-    public void loadExtra(YAPIONObject phaseObject) {
+    public void loadExtra(SimulatorConfig.Phase phase) {
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/data/observer/ObserverPhase.java

@@ -21,6 +21,7 @@ package de.steamwar.bausystem.features.simulator.data.observer;
 
 import de.steamwar.bausystem.features.simulator.data.SimulatorPhase;
 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import lombok.Getter;
 import lombok.NoArgsConstructor;
 import lombok.Setter;
@@ -31,7 +32,6 @@ import org.bukkit.block.BlockFace;
 import org.bukkit.block.BlockState;
 import org.bukkit.block.data.type.Observer;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.function.BiConsumer;
 
@@ -70,12 +70,12 @@ public final class ObserverPhase extends SimulatorPhase {
     }
 
     @Override
-    public void saveExtra(YAPIONObject phaseObject) {
-        phaseObject.add("orientation", orientation.name());
+    public void saveExtra(SimulatorConfig.Phase phase) {
+        phase.setOrientation(orientation);
     }
 
     @Override
-    public void loadExtra(YAPIONObject phaseObject) {
-        orientation = BlockFace.valueOf(phaseObject.getPlainValue("orientation"));
+    public void loadExtra(SimulatorConfig.Phase phase) {
+        if (phase.getOrientation() != null) orientation = phase.getOrientation();
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/data/tnt/TNTElement.java

@@ -24,13 +24,13 @@ import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.gui.SimulatorTNTGui;
 import de.steamwar.bausystem.features.simulator.gui.base.SimulatorBaseGui;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import de.steamwar.inventory.InvCallback;
 import de.steamwar.inventory.SWItem;
 import lombok.Getter;
 import org.bukkit.Material;
 import org.bukkit.entity.Player;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;
 
 public final class TNTElement extends SimulatorElement<TNTPhase> {
 
@@ -100,14 +100,14 @@ public final class TNTElement extends SimulatorElement<TNTPhase> {
     }
 
     @Override
-    public void saveExtra(YAPIONObject elementObject) {
-        elementObject.add("alignmentX", alignment.getX());
-        elementObject.add("alignmentZ", alignment.getZ());
+    public void saveExtra(SimulatorConfig.Element element) {
+        element.setAlignmentX(alignment.getX());
+        element.setAlignmentZ(alignment.getZ());
     }
 
     @Override
-    public void loadExtra(YAPIONObject elementObject) {
-        alignment.setX(elementObject.getDoubleOrSetDefault("alignmentX", 0));
-        alignment.setZ(elementObject.getDoubleOrSetDefault("alignmentZ", 0));
+    public void loadExtra(SimulatorConfig.Element element) {
+        alignment.setX(element.getAlignmentX() != null ? element.getAlignmentX() : 0);
+        alignment.setZ(element.getAlignmentZ() != null ? element.getAlignmentZ() : 0);
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/data/tnt/TNTPhase.java

@@ -21,6 +21,7 @@ package de.steamwar.bausystem.features.simulator.data.tnt;
 
 import de.steamwar.bausystem.features.simulator.data.SimulatorPhase;
 import de.steamwar.bausystem.features.simulator.execute.SimulatorAction;
+import de.steamwar.bausystem.features.simulator.storage.SimulatorConfig;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.bausystem.region.flags.Flag;
 import de.steamwar.bausystem.region.flags.FreezeMode;
@@ -31,7 +32,6 @@ import org.bukkit.Location;
 import org.bukkit.World;
 import org.bukkit.entity.TNTPrimed;
 import org.bukkit.util.Vector;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.function.BiConsumer;
 
@@ -83,18 +83,18 @@ public final class TNTPhase extends SimulatorPhase {
     }
 
     @Override
-    public void saveExtra(YAPIONObject phaseObject) {
-        phaseObject.add("count", count);
-        phaseObject.add("xJump", xJump);
-        phaseObject.add("yJump", yJump);
-        phaseObject.add("zJump", zJump);
+    public void saveExtra(SimulatorConfig.Phase phase) {
+        phase.setCount(count);
+        phase.setXJump(xJump);
+        phase.setYJump(yJump);
+        phase.setZJump(zJump);
     }
 
     @Override
-    public void loadExtra(YAPIONObject phaseObject) {
-        count = phaseObject.getPlainValue("count");
-        xJump = phaseObject.getPlainValue("xJump");
-        yJump = phaseObject.getPlainValue("yJump");
-        zJump = phaseObject.getPlainValue("zJump");
+    public void loadExtra(SimulatorConfig.Phase phase) {
+        if (phase.getCount() != null) count = phase.getCount();
+        if (phase.getXJump() != null) xJump = phase.getXJump();
+        if (phase.getYJump() != null) yJump = phase.getYJump();
+        if (phase.getZJump() != null) zJump = phase.getZJump();
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/storage/SimFormatSimulatorLoader.java

@@ -19,6 +19,7 @@
 
 package de.steamwar.bausystem.features.simulator.storage;
 
+import com.google.gson.JsonParseException;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorElement;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
@@ -29,12 +30,7 @@ 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 org.bukkit.Material;
 import org.bukkit.util.Vector;
-import yapion.exceptions.YAPIONException;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
 
 import java.io.File;
 import java.io.IOException;
@@ -51,44 +47,41 @@ public class SimFormatSimulatorLoader implements SimulatorLoader {
             return Optional.empty();
         }
 
-        YAPIONObject yapionObject;
+        SimulatorConfig config;
         try {
-            yapionObject = YAPIONParser.parse(file);
-        } catch (YAPIONException | IOException e) {
+            config = SimulatorConfig.STORE.load(file);
+        } catch (JsonParseException | IllegalStateException | IOException e) {
             return Optional.empty();
         }
 
         String name = file.getName().substring(0, file.getName().length() - ".sim".length());
 
         Simulator simulator = new Simulator(name);
-        loadSimulator(yapionObject, simulator);
+        loadSimulator(config, simulator);
         return Optional.of(Collections.singletonList(simulator));
     }
 
-    private void loadSimulator(YAPIONObject simulatorObject, Simulator simulator) {
-        simulator.setMaterial(Material.valueOf(simulatorObject.getPlainValue("material")));
-        simulator.setAutoTrace(simulatorObject.getPlainValue("autoTrace"));
-        simulator.setAutoTestblock(simulatorObject.getPlainValueOrDefault("autoTestblock", false));
+    private void loadSimulator(SimulatorConfig config, Simulator simulator) {
+        if (config.getMaterial() != null) simulator.setMaterial(config.getMaterial());
+        simulator.setAutoTrace(config.isAutoTrace());
+        simulator.setAutoTestblock(config.isAutoTestblock());
 
-        YAPIONArray groups = simulatorObject.getArray("groups");
-        groups.streamObject().forEach(groupObject -> {
+        config.getGroups().forEach(groupConfig -> {
             SimulatorGroup simulatorGroup = new SimulatorGroup();
-            loadGroup(groupObject, simulatorGroup);
+            loadGroup(groupConfig, simulatorGroup);
             simulator.add(simulatorGroup);
         });
     }
 
-    private void loadGroup(YAPIONObject groupObject, SimulatorGroup group) {
-        group.setMaterial(Material.valueOf(groupObject.getPlainValue("material")));
-        group.setDisabled(groupObject.getPlainValue("disabled"));
+    private void loadGroup(SimulatorConfig.Group groupConfig, SimulatorGroup group) {
+        if (groupConfig.getMaterial() != null) group.setMaterial(groupConfig.getMaterial());
+        group.setDisabled(groupConfig.isDisabled());
 
-        YAPIONArray elements = groupObject.getArray("elements");
-        elements.streamObject().forEach(elementObject -> {
+        groupConfig.getElements().forEach(elementConfig -> {
             SimulatorElement<?> element;
             Supplier<SimulatorPhase> phaseConstructor;
-            Vector position = new Vector(elementObject.getDouble("x"), elementObject.getDouble("y"), elementObject.getDouble("z"));
-            String type = elementObject.getPlainValue("type");
-            switch (type) {
+            Vector position = new Vector(elementConfig.getX(), elementConfig.getY(), elementConfig.getZ());
+            switch (String.valueOf(elementConfig.getType())) {
                 case "TNT":
                     element = new TNTElement(position);
                     phaseConstructor = TNTPhase::new;
@@ -109,28 +102,27 @@ public class SimFormatSimulatorLoader implements SimulatorLoader {
             if (element == null) {
                 return;
             }
-            loadElement(elementObject, element, phaseConstructor);
+            loadElement(elementConfig, element, phaseConstructor);
             group.add(element);
         });
     }
 
-    private void loadElement(YAPIONObject elementObject, SimulatorElement<?> element, Supplier<SimulatorPhase> phaseConstructor) {
-        element.setMaterial(Material.valueOf(elementObject.getPlainValue("material")));
-        element.setDisabled(elementObject.getPlainValue("disabled"));
-        element.loadExtra(elementObject);
+    private void loadElement(SimulatorConfig.Element elementConfig, SimulatorElement<?> element, Supplier<SimulatorPhase> phaseConstructor) {
+        if (elementConfig.getMaterial() != null) element.setMaterial(elementConfig.getMaterial());
+        element.setDisabled(elementConfig.isDisabled());
+        element.loadExtra(elementConfig);
 
-        YAPIONArray phases = elementObject.getArray("phases");
-        phases.streamObject().forEach(phaseObject -> {
+        elementConfig.getPhases().forEach(phaseConfig -> {
             SimulatorPhase phase = phaseConstructor.get();
-            loadPhase(phaseObject, phase);
+            loadPhase(phaseConfig, phase);
             ((SimulatorElement) element).add(phase);
         });
     }
 
-    private void loadPhase(YAPIONObject phaseObject, SimulatorPhase phase) {
-        phase.setTickOffset(phaseObject.getPlainValue("tickOffset"));
-        phase.setLifetime(phaseObject.getPlainValue("lifetime"));
-        phase.setOrder(phaseObject.getPlainValue("order"));
-        phase.loadExtra(phaseObject);
+    private void loadPhase(SimulatorConfig.Phase phaseConfig, SimulatorPhase phase) {
+        phase.setTickOffset(phaseConfig.getTickOffset());
+        phase.setLifetime(phaseConfig.getLifetime());
+        phase.setOrder(phaseConfig.getOrder());
+        phase.loadExtra(phaseConfig);
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/storage/SimulatorConfig.java

@@ -0,0 +1,117 @@
+/*
+ *   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.simulator.storage;
+
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The current stored form of a simulator, saved as JSON in a .sim file. Files
+ * saved before the version was stored have no version and are version 1.
+ * Fields missing in the stored JSON keep the default value of their initializer,
+ * so adding a new field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to SimulatorConfigV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION}, write a
+ * {@link de.steamwar.bausystem.config.ConfigConverter} from the copy to
+ * this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class SimulatorConfig implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    /**
+     * Files saved before the version was stored are version 1
+     */
+    public static final ConfigStore<SimulatorConfig> STORE = new ConfigStore<>(SimulatorConfig.class, VERSION, SimulatorConfig::new)
+            .unversioned(1);
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    protected Material material = Material.BARREL;
+    protected boolean autoTrace = false;
+    protected boolean autoTestblock = false;
+    protected List<Group> groups = new ArrayList<>();
+
+    @Getter
+    @Setter
+    public static class Group {
+
+        protected Material material = Material.CHEST;
+        protected boolean disabled = false;
+        protected List<Element> elements = new ArrayList<>();
+    }
+
+    @Getter
+    @Setter
+    public static class Element {
+
+        /**
+         * One of "TNT", "Redstone" or "Observer"
+         */
+        protected String type;
+        protected Material material;
+        protected boolean disabled = false;
+        protected double x;
+        protected double y;
+        protected double z;
+
+        /**
+         * Only used by TNT
+         */
+        protected Double alignmentX;
+        protected Double alignmentZ;
+
+        protected List<Phase> phases = new ArrayList<>();
+    }
+
+    @Getter
+    @Setter
+    public static class Phase {
+
+        protected int tickOffset;
+        protected int lifetime;
+        protected int order;
+
+        /**
+         * Only used by TNT
+         */
+        protected Integer count;
+        protected Boolean xJump;
+        protected Boolean yJump;
+        protected Boolean zJump;
+
+        /**
+         * Only used by Observer
+         */
+        protected BlockFace orientation;
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/storage/SimulatorFormatSimulatorLoader.java

@@ -19,24 +19,30 @@
 
 package de.steamwar.bausystem.features.simulator.storage;
 
+import de.steamwar.bausystem.config.legacy.YapionReader;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
 import org.bukkit.Material;
 import org.bukkit.util.Vector;
-import yapion.exceptions.YAPIONException;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.util.Collections;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
+import static de.steamwar.bausystem.config.legacy.YapionReader.*;
+
+/**
+ * Loads the legacy .simulator files stored as YAPION, they are deleted after loading
+ * and saved in the current format by the {@link SimulatorSaver}.
+ */
+@Deprecated
 public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
 
     @Override
@@ -45,20 +51,19 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
             return Optional.empty();
         }
 
-        YAPIONObject yapionObject;
+        Map<String, Object> yapionObject;
         try {
-            yapionObject = YAPIONParser.parse(file);
-        } catch (YAPIONException | IOException e) {
+            yapionObject = YapionReader.parse(Files.readString(file.toPath(), StandardCharsets.UTF_8));
+        } catch (IllegalArgumentException | IOException e) {
             return Optional.empty();
         }
 
         String name = file.getName().substring(0, file.getName().length() - ".simulator".length());
 
         Simulator simulator = new Simulator(name);
-        simulator.setMaterial(Material.valueOf(yapionObject.getStringOrDefault("material", "BARREL")));
+        simulator.setMaterial(Material.valueOf(getString(yapionObject, "material", "BARREL")));
 
-        YAPIONArray tntElements = yapionObject.getArrayOrDefault("tntElements", new YAPIONArray());
-        for (YAPIONObject element : tntElements.streamObject().collect(Collectors.toList())) {
+        for (Map<?, ?> element : getObjects(yapionObject, "tntElements")) {
             if (element.containsKey("elements")) {
                 simulator.add(loadGroup(element));
             } else {
@@ -70,27 +75,26 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
         return Optional.of(Collections.singletonList(simulator));
     }
 
-    private SimulatorGroup loadGroup(YAPIONObject element) {
-        double x = element.getDoubleOrDefault("x", 0);
-        double y = element.getDoubleOrDefault("y", 0);
-        double z = element.getDoubleOrDefault("z", 0);
-        int tickOffset = element.getIntOrDefault("tickOffset", 0);
+    private SimulatorGroup loadGroup(Map<?, ?> element) {
+        double x = getDouble(element, "x", 0);
+        double y = getDouble(element, "y", 0);
+        double z = getDouble(element, "z", 0);
+        int tickOffset = getInt(element, "tickOffset", 0);
 
         SimulatorGroup simulatorGroup = new SimulatorGroup();
-        simulatorGroup.setDisabled(element.getBooleanOrDefault("disabled", false));
+        simulatorGroup.setDisabled(getBoolean(element, "disabled", false));
 
-        YAPIONArray elements = element.getArrayOrDefault("elements", new YAPIONArray());
-        for (YAPIONObject e : elements.streamObject().collect(Collectors.toList())) {
+        for (Map<?, ?> e : getObjects(element, "elements")) {
             simulatorGroup.add(loadElement(e, x, y, z, tickOffset));
         }
 
         return simulatorGroup;
     }
 
-    private TNTElement loadElement(YAPIONObject element, double dx, double dy, double dz, int dTickOffset) {
-        TNTElement tntElement = new TNTElement(new Vector(element.getDouble("x") + dx, element.getDouble("y") + dy, element.getDouble("z") + dz));
-        tntElement.setDisabled(element.getBooleanOrDefault("disabled", false));
-        tntElement.setMaterial(Material.valueOf(element.getStringOrDefault("material", "TNT")));
+    private TNTElement loadElement(Map<?, ?> element, double dx, double dy, double dz, int dTickOffset) {
+        TNTElement tntElement = new TNTElement(new Vector(requireDouble(element, "x") + dx, requireDouble(element, "y") + dy, requireDouble(element, "z") + dz));
+        tntElement.setDisabled(getBoolean(element, "disabled", false));
+        tntElement.setMaterial(Material.valueOf(getString(element, "material", "TNT")));
 
         TNTPhase tntPhase = loadPhase(element);
         tntPhase.setTickOffset(tntPhase.getTickOffset() + dTickOffset);
@@ -99,12 +103,12 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
         return tntElement;
     }
 
-    private SimulatorGroup loadElement(YAPIONObject element) {
+    private SimulatorGroup loadElement(Map<?, ?> element) {
         SimulatorGroup simulatorGroup = new SimulatorGroup();
 
-        TNTElement tntElement = new TNTElement(new Vector(element.getDouble("x"), element.getDouble("y"), element.getDouble("z")));
-        tntElement.setDisabled(element.getBooleanOrDefault("disabled", false));
-        tntElement.setMaterial(Material.valueOf(element.getStringOrDefault("material", "TNT")));
+        TNTElement tntElement = new TNTElement(new Vector(requireDouble(element, "x"), requireDouble(element, "y"), requireDouble(element, "z")));
+        tntElement.setDisabled(getBoolean(element, "disabled", false));
+        tntElement.setMaterial(Material.valueOf(getString(element, "material", "TNT")));
         simulatorGroup.add(tntElement);
 
         tntElement.add(loadPhase(element));
@@ -112,15 +116,15 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
         return simulatorGroup;
     }
 
-    private TNTPhase loadPhase(YAPIONObject element) {
+    private TNTPhase loadPhase(Map<?, ?> element) {
         TNTPhase tntPhase = new TNTPhase();
-        tntPhase.setLifetime(element.getIntOrDefault("fuseTicks", 80));
-        tntPhase.setCount(element.getIntOrDefault("count", 1));
-        tntPhase.setTickOffset(element.getIntOrDefault("tickOffset", 0));
-        tntPhase.setXJump(element.getBooleanOrDefault("xVelocity", false));
-        tntPhase.setYJump(element.getBooleanOrDefault("yVelocity", false));
-        tntPhase.setZJump(element.getBooleanOrDefault("zVelocity", false));
-        switch (element.getStringOrDefault("order", "REPEATER")) {
+        tntPhase.setLifetime(getInt(element, "fuseTicks", 80));
+        tntPhase.setCount(getInt(element, "count", 1));
+        tntPhase.setTickOffset(getInt(element, "tickOffset", 0));
+        tntPhase.setXJump(getBoolean(element, "xVelocity", false));
+        tntPhase.setYJump(getBoolean(element, "yVelocity", false));
+        tntPhase.setZJump(getBoolean(element, "zVelocity", false));
+        switch (getString(element, "order", "REPEATER")) {
             case "REPEATER":
                 tntPhase.setOrder(0);
                 break;
@@ -133,4 +137,8 @@ public class SimulatorFormatSimulatorLoader implements SimulatorLoader {
         }
         return tntPhase;
     }
+
+    private double requireDouble(Map<?, ?> element, String key) {
+        return ((Number) element.get(key)).doubleValue();
+    }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/storage/SimulatorSaver.java

@@ -21,9 +21,6 @@ package de.steamwar.bausystem.features.simulator.storage;
 
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import lombok.experimental.UtilityClass;
-import yapion.hierarchy.output.FileOutput;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.io.File;
 import java.io.IOException;
@@ -36,48 +33,42 @@ public class SimulatorSaver {
             directory.mkdirs();
         }
 
-        YAPIONObject simulatorObject = new YAPIONObject();
-        simulatorObject.add("material", simulator.getMaterial().name());
-        simulatorObject.add("autoTrace", simulator.isAutoTrace());
-        simulatorObject.add("autoTestblock", simulator.isAutoTestblock());
+        SimulatorConfig config = new SimulatorConfig();
+        config.setMaterial(simulator.getMaterial());
+        config.setAutoTrace(simulator.isAutoTrace());
+        config.setAutoTestblock(simulator.isAutoTestblock());
 
-        YAPIONArray groups = new YAPIONArray();
         simulator.getGroups().forEach(group -> {
-            YAPIONObject groupObject = new YAPIONObject();
-            groupObject.add("material", group.getMaterial().name());
-            groupObject.add("disabled", group.isDisabled());
+            SimulatorConfig.Group groupConfig = new SimulatorConfig.Group();
+            groupConfig.setMaterial(group.getMaterial());
+            groupConfig.setDisabled(group.isDisabled());
 
-            YAPIONArray elements = new YAPIONArray();
             group.getElements().forEach(element -> {
-                YAPIONObject elementObject = new YAPIONObject();
-                elementObject.add("type", element.getType());
-                elementObject.add("material", element.getMaterial().name());
-                elementObject.add("disabled", element.isDisabled());
-                elementObject.add("x", element.getPosition().getX());
-                elementObject.add("y", element.getPosition().getY());
-                elementObject.add("z", element.getPosition().getZ());
-                element.saveExtra(elementObject);
+                SimulatorConfig.Element elementConfig = new SimulatorConfig.Element();
+                elementConfig.setType(element.getType());
+                elementConfig.setMaterial(element.getMaterial());
+                elementConfig.setDisabled(element.isDisabled());
+                elementConfig.setX(element.getPosition().getX());
+                elementConfig.setY(element.getPosition().getY());
+                elementConfig.setZ(element.getPosition().getZ());
+                element.saveExtra(elementConfig);
 
-                YAPIONArray phases = new YAPIONArray();
                 element.getPhases().forEach(phase -> {
-                    YAPIONObject phaseObject = new YAPIONObject();
-                    phaseObject.add("tickOffset", phase.getTickOffset());
-                    phaseObject.add("lifetime", phase.getLifetime());
-                    phaseObject.add("order", phase.getOrder());
-                    phase.saveExtra(phaseObject);
-                    phases.add(phaseObject);
+                    SimulatorConfig.Phase phaseConfig = new SimulatorConfig.Phase();
+                    phaseConfig.setTickOffset(phase.getTickOffset());
+                    phaseConfig.setLifetime(phase.getLifetime());
+                    phaseConfig.setOrder(phase.getOrder());
+                    phase.saveExtra(phaseConfig);
+                    elementConfig.getPhases().add(phaseConfig);
                 });
-                elementObject.add("phases", phases);
-                elements.add(elementObject);
+                groupConfig.getElements().add(elementConfig);
             });
-            groupObject.add("elements", elements);
-            groups.add(groupObject);
+            config.getGroups().add(groupConfig);
         });
-        simulatorObject.add("groups", groups);
 
         File file = new File(directory, simulator.getName() + ".sim");
         try {
-            simulatorObject.toJSONLossy(new FileOutput(file)).close();
+            SimulatorConfig.STORE.save(file, config);
         } catch (IOException e) {
             // Ignore
         }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/storage/YAPIONFormatSimulatorLoader.java

@@ -19,6 +19,7 @@
 
 package de.steamwar.bausystem.features.simulator.storage;
 
+import de.steamwar.bausystem.config.legacy.YapionReader;
 import de.steamwar.bausystem.features.simulator.data.Simulator;
 import de.steamwar.bausystem.features.simulator.data.SimulatorGroup;
 import de.steamwar.bausystem.features.simulator.data.tnt.TNTElement;
@@ -26,18 +27,23 @@ import de.steamwar.bausystem.features.simulator.data.tnt.TNTPhase;
 import de.steamwar.sql.SteamwarUser;
 import org.bukkit.Material;
 import org.bukkit.util.Vector;
-import yapion.exceptions.YAPIONException;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
 
 import java.io.File;
 import java.io.IOException;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
+import static de.steamwar.bausystem.config.legacy.YapionReader.*;
+
+/**
+ * Loads the legacy per player .yapion files containing multiple simulators, they are
+ * deleted after loading and saved in the current format by the {@link SimulatorSaver}.
+ */
+@Deprecated
 public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
 
     @Override
@@ -46,10 +52,10 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
             return Optional.empty();
         }
 
-        YAPIONObject yapionObject;
+        Map<String, Object> yapionObject;
         try {
-            yapionObject = YAPIONParser.parse(file);
-        } catch (YAPIONException | IOException e) {
+            yapionObject = YapionReader.parse(Files.readString(file.toPath(), StandardCharsets.UTF_8));
+        } catch (IllegalArgumentException | IOException e) {
             return Optional.empty();
         }
 
@@ -57,28 +63,28 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
         SteamwarUser steamwarUser = SteamwarUser.byId(Integer.parseInt(name));
 
         List<Simulator> simulators = new ArrayList<>();
-        for (String s : yapionObject.getKeys()) {
+        for (String s : yapionObject.keySet()) {
             String newName = steamwarUser.getUserName() + (s.isEmpty() ? "" : "_" + s);
-            YAPIONArray content = yapionObject.getArray(s);
+            List<Map<?, ?>> content = getObjects(yapionObject, s);
             if (content.isEmpty()) continue;
             Simulator simulator = new Simulator(newName);
-            for (YAPIONObject element : content.streamObject().collect(Collectors.toList())) {
+            for (Map<?, ?> element : content) {
                 SimulatorGroup simulatorGroup = new SimulatorGroup();
                 simulator.add(simulatorGroup);
 
-                TNTElement tntElement = new TNTElement(new Vector(element.getDouble("positionX"), element.getDouble("positionY"), element.getDouble("positionZ")));
-                tntElement.setDisabled(element.getBooleanOrDefault("disabled", false)); // IDK if this existed back then?
-                tntElement.setMaterial(Material.valueOf(element.getStringOrDefault("material", "TNT")));
+                TNTElement tntElement = new TNTElement(new Vector(requireDouble(element, "positionX"), requireDouble(element, "positionY"), requireDouble(element, "positionZ")));
+                tntElement.setDisabled(getBoolean(element, "disabled", false)); // IDK if this existed back then?
+                tntElement.setMaterial(Material.valueOf(getString(element, "material", "TNT")));
                 simulatorGroup.add(tntElement);
 
                 TNTPhase tntPhase = new TNTPhase();
-                tntPhase.setLifetime(element.getIntOrDefault("fuseTicks", 80));
-                tntPhase.setCount(element.getIntOrDefault("count", 1));
-                tntPhase.setTickOffset(element.getIntOrDefault("tickOffset", 0));
-                tntPhase.setXJump(element.getBooleanOrDefault("xVelocity", false));
-                tntPhase.setYJump(element.getBooleanOrDefault("yVelocity", false));
-                tntPhase.setZJump(element.getBooleanOrDefault("zVelocity", false));
-                tntPhase.setOrder(element.getBooleanOrDefault("comparator", false) ? 2 : 0);
+                tntPhase.setLifetime(getInt(element, "fuseTicks", 80));
+                tntPhase.setCount(getInt(element, "count", 1));
+                tntPhase.setTickOffset(getInt(element, "tickOffset", 0));
+                tntPhase.setXJump(getBoolean(element, "xVelocity", false));
+                tntPhase.setYJump(getBoolean(element, "yVelocity", false));
+                tntPhase.setZJump(getBoolean(element, "zVelocity", false));
+                tntPhase.setOrder(getBoolean(element, "comparator", false) ? 2 : 0);
                 tntElement.add(tntPhase);
             }
             simulators.add(simulator);
@@ -87,4 +93,8 @@ public class YAPIONFormatSimulatorLoader implements SimulatorLoader {
         file.delete();
         return Optional.of(simulators);
     }
+
+    private double requireDouble(Map<?, ?> element, String key) {
+        return ((Number) element.get(key)).doubleValue();
+    }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/BlockBoundingBox.java

@@ -19,48 +19,97 @@
 
 package de.steamwar.bausystem.features.slaves.laufbau;
 
-import com.sk89q.worldedit.blocks.SkullBlock;
-import com.sk89q.worldedit.world.block.BaseBlock;
-import de.steamwar.inventory.SWItem;
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.api.Enable;
 import lombok.Getter;
 import lombok.ToString;
+import net.minecraft.core.BlockPos;
+import net.minecraft.locale.Language;
+import net.minecraft.world.level.EmptyBlockGetter;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.phys.shapes.CollisionContext;
 import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.Bisected;
+import org.bukkit.Registry;
 import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.Directional;
 import org.bukkit.block.data.Waterlogged;
-import org.bukkit.block.data.type.*;
+import org.bukkit.block.data.type.Bed;
+import org.bukkit.block.data.type.Door;
+import org.bukkit.craftbukkit.block.CraftBlockType;
+import org.bukkit.craftbukkit.block.data.CraftBlockData;
+import org.bukkit.craftbukkit.util.CraftVoxelShape;
+import org.bukkit.util.BoundingBox;
+import org.bukkit.util.VoxelShape;
 
 import java.util.ArrayList;
-import java.util.Arrays;
+import java.util.Collection;
+import java.util.Comparator;
 import java.util.List;
-import java.util.Random;
-import java.util.function.Consumer;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+import java.util.stream.Collectors;
 
 @ToString
 @Getter
 public class BlockBoundingBox {
 
-    private static List<String> randomPlayerHead = new ArrayList<>();
-    private static Random random = new Random();
+    @Linked
+    public static class Loader implements Enable {
 
-    static {
-        randomPlayerHead.add("zOnlyKroks");
-        randomPlayerHead.add("YoyoNow");
-        randomPlayerHead.add("Konstruktix");
-        randomPlayerHead.add("Merling03");
-        randomPlayerHead.add("Lord_Loading");
-        /*
-        randomPlayerHead.add(UUID.fromString("1623d4b1-b21c-41d3-93c2-eee2845b8497"));
-        randomPlayerHead.add(UUID.fromString("f75632be-e3ec-4069-9bec-d13ac6891177"));
-        randomPlayerHead.add(UUID.fromString("80382970-424b-4299-9296-d956beab9e7b"));
-        randomPlayerHead.add(UUID.fromString("f395ce89-096d-48e9-b796-a2d88722c22b"));
-        randomPlayerHead.add(UUID.fromString("db516394-d999-4b77-8d13-73cceec77dfe"));
-         */
+        @Override
+        public void enable() {
+            long time = System.currentTimeMillis();
+            Registry.BLOCK.forEach(blockType -> {
+                Block block = CraftBlockType.bukkitToMinecraftNew(blockType);
+                Material material = blockType.asMaterial();
+                if (!material.isItem()) return;
+                if (!material.isBlock()) return;
+                if (material == Material.WATER) return;
+                if (material.getBlastResistance() <= 0.0) return;
+                if (material.getBlastResistance() > 9.0) return;
+
+                block.getStateDefinition().getPossibleStates().forEach(blockState -> {
+                    VoxelShape voxelShape = new CraftVoxelShape(blockState.getCollisionShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO, CollisionContext.empty()));
+                    Collection<BoundingBox> boundingBoxes = voxelShape.getBoundingBoxes();
+                    if (boundingBoxes.isEmpty()) return;
+
+                    double minX = Double.MAX_VALUE;
+                    double minY = Double.MAX_VALUE;
+                    double minZ = Double.MAX_VALUE;
+                    double maxX = Double.MIN_VALUE;
+                    double maxY = Double.MIN_VALUE;
+                    double maxZ = Double.MIN_VALUE;
+                    for (BoundingBox boundingBox : boundingBoxes) {
+                        minX = Math.min(minX, boundingBox.getMinX());
+                        minY = Math.min(minY, boundingBox.getMinY());
+                        minZ = Math.min(minZ, boundingBox.getMinZ());
+
+                        maxX = Math.max(maxX, boundingBox.getMaxX());
+                        maxY = Math.max(maxY, boundingBox.getMaxY());
+                        maxZ = Math.max(maxZ, boundingBox.getMaxZ());
+                    }
+
+                    // Ignore Full Blocks
+                    if (maxX - minX == 1 && maxY - minY == 1 && maxZ - minZ == 1) return;
+
+                    BlockData blockData = CraftBlockData.createData(blockState);
+                    if (blockData instanceof Door) return; // Doors dont seem to be 2 blocks tall?
+                    if (blockData instanceof Bed) return;  // Beds dont seem to be 2 blocks tall?
+                    if (blockData instanceof Waterlogged waterlogged && waterlogged.isWaterlogged()) return;
+
+                    String key = material.isItem()
+                            ? material.getItemTranslationKey()   // "item.minecraft.diamond" / "block.minecraft.stone"
+                            : material.getBlockTranslationKey(); // for block-only materials like WATER
+
+                    new BlockBoundingBox(
+                            blockData,
+                            boundingBoxes.stream().map(Cuboid::new).collect(Collectors.toList()),
+                            material,
+                            "§f" + Language.getInstance().getOrDefault(key)
+                    );
+                });
+            });
+            BauSystem.getInstance().getLogger().info("Laufbau init > " + (System.currentTimeMillis() - time) + "ms " + elements.size() + " blocks");
+            elements.sort(Comparator.<BlockBoundingBox>comparingDouble(value -> value.material.getBlastResistance()).thenComparing(value -> value.name));
+        }
     }
 
     public static List<BlockBoundingBox> elements = new ArrayList<>();
@@ -68,221 +117,32 @@ public class BlockBoundingBox {
     public BlockData blockData;
     public List<Cuboid> cuboidList;
     private double volume;
-    public SWItem swItem;
+    public Material material;
+    public String name;
 
-    public Consumer<BaseBlock> blockConsumer = null;
-
-    public BlockBoundingBox(BlockData blockData, List<Cuboid> cuboidList, SWItem swItem) {
+    public BlockBoundingBox(BlockData blockData, List<Cuboid> cuboidList, Material material, String name) {
         this.blockData = blockData;
         this.cuboidList = cuboidList;
-        this.swItem = swItem;
+        this.material = material;
+        this.name = name;
         volume = cuboidList.stream().mapToDouble(Cuboid::volume).sum();
-        elements.add(this);
-    }
 
-    public BlockBoundingBox(BlockData blockData, List<Cuboid> cuboidList, SWItem swItem, Consumer<BaseBlock> blockConsumer) {
-        this.blockData = blockData;
-        this.cuboidList = cuboidList;
-        this.swItem = swItem;
-        volume = cuboidList.stream().mapToDouble(Cuboid::volume).sum();
+        // Override/Ignore items with worse/better blast resistance
+        for (int i = 0; i < elements.size(); i++) {
+            BlockBoundingBox other = elements.get(i);
+            if (other.cuboidList.equals(cuboidList)) {
+                if (other.material.getBlastResistance() < material.getBlastResistance()) {
+                    elements.remove(i);
+                    break;
+                } else {
+                    return;
+                }
+            }
+        }
         elements.add(this);
-        this.blockConsumer = blockConsumer;
     }
 
     public double volume() {
         return volume;
     }
-
-    static {
-        addPixel(Material.AIR.createBlockData(), 0, 0, 0, 0, 0, 0, null);
-        // addPixel(Material.COBWEB.createBlockData(), 0, 0, 0, 0, 0, 0, createItem("LAUFBAU_BLOCK_COBWEB", Material.COBWEB));
-        addPixel(Material.END_STONE.createBlockData(), 0, 0, 0, 16, 16, 16, null);
-
-        addPixel(Material.DIRT_PATH.createBlockData(), 0, 0, 0, 16, 15, 16, createItem("LAUFBAU_BLOCK_GRASS_PATH", Material.DIRT_PATH));
-        addPixel(Material.MUD.createBlockData(), 0, 0, 0, 16, 14, 16, createItem("LAUFBAU_BLOCK_SOUL_SAND", Material.SOUL_SAND));
-
-        Cocoa cocoaNorth = (Cocoa) Material.COCOA.createBlockData();
-        cocoaNorth.setAge(2);
-        cocoaNorth.setFacing(BlockFace.NORTH);
-        addPixel(cocoaNorth, 4, 3, 1, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_NORTH"));
-
-        Cocoa cocoaSouth = (Cocoa) Material.COCOA.createBlockData();
-        cocoaSouth.setAge(2);
-        cocoaSouth.setFacing(BlockFace.SOUTH);
-        addPixel(cocoaSouth, 4, 3, 7, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_SOUTH"));
-
-        Cocoa cocoaWest = (Cocoa) Material.COCOA.createBlockData();
-        cocoaWest.setAge(2);
-        cocoaWest.setFacing(BlockFace.WEST);
-        addPixel(cocoaWest, 1, 3, 4, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_WEST"));
-
-        Cocoa cocoaEast = (Cocoa) Material.COCOA.createBlockData();
-        cocoaEast.setAge(2);
-        cocoaEast.setFacing(BlockFace.EAST);
-        addPixel(cocoaEast, 7, 3, 4, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_EAST"));
-
-        TurtleEgg singleTurtleEgg = (TurtleEgg) Material.TURTLE_EGG.createBlockData();
-        singleTurtleEgg.setEggs(1);
-        singleTurtleEgg.setHatch(0);
-        addPixel(singleTurtleEgg, 4, 0, 3, 9, 7, 9, createItem("LAUFBAU_BLOCK_TURTLE_EGG", Material.TURTLE_EGG, "LAUFBAU_COUNT_1"));
-
-        TurtleEgg doubleTurtleEgg = (TurtleEgg) Material.TURTLE_EGG.createBlockData();
-        doubleTurtleEgg.setEggs(2);
-        doubleTurtleEgg.setHatch(0);
-        addPixel(doubleTurtleEgg, 1, 0, 1, 14, 7, 14, createItem("LAUFBAU_BLOCK_TURTLE_EGG", Material.TURTLE_EGG, "LAUFBAU_COUNT_2"));
-
-        addPixel(Material.CHEST.createBlockData(), 1, 0, 1, 14, 14, 14, createItem("LAUFBAU_BLOCK_CHEST", Material.CHEST));
-
-        Snow snowLayers8 = (Snow) Material.SNOW.createBlockData();
-        snowLayers8.setLayers(8);
-        addPixel(snowLayers8, 0, 0, 0, 16, 14, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_8"));
-
-        Directional headNorth = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
-        headNorth.setFacing(BlockFace.NORTH);
-        addPixel(headNorth, 4, 4, 8, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_NORTH"), BlockBoundingBox::randomPlayerHead);
-
-        Directional headSouth = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
-        headSouth.setFacing(BlockFace.SOUTH);
-        addPixel(headSouth, 4, 4, 0, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_SOUTH"), BlockBoundingBox::randomPlayerHead);
-
-        Directional headWest = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
-        headWest.setFacing(BlockFace.WEST);
-        addPixel(headWest, 8, 4, 4, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_WEST"), BlockBoundingBox::randomPlayerHead);
-
-        Directional headEast = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
-        headEast.setFacing(BlockFace.EAST);
-        addPixel(headEast, 0, 4, 4, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_EAST"), BlockBoundingBox::randomPlayerHead);
-
-        Snow snowLayers7 = (Snow) Material.SNOW.createBlockData();
-        snowLayers7.setLayers(7);
-        addPixel(snowLayers7, 0, 0, 0, 16, 12, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_7"));
-
-        Snow snowLayers6 = (Snow) Material.SNOW.createBlockData();
-        snowLayers6.setLayers(6);
-        addPixel(snowLayers6, 0, 0, 0, 16, 10, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_6"));
-
-        addPixel(Material.STONECUTTER.createBlockData(), 0, 0, 0, 16, 9, 16, createItem("LAUFBAU_BLOCK_STONECUTTER", Material.STONECUTTER));
-
-        addPixel(Material.PLAYER_HEAD.createBlockData(), 4, 0, 4, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_HEAD", Material.PLAYER_HEAD), BlockBoundingBox::randomPlayerHead);
-
-        addPixel(Material.CAKE.createBlockData(), 1, 0, 1, 14, 8, 14, createItem("LAUFBAU_BLOCK_CAKE", Material.CAKE));
-
-        Slab bottomSlab = (Slab) Material.END_STONE_BRICK_SLAB.createBlockData();
-        bottomSlab.setType(Slab.Type.BOTTOM);
-        addPixel(bottomSlab, 0, 0, 0, 16, 8, 16, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_SLAB", Material.END_STONE_BRICK_SLAB, "LAUFBAU_TYPE_BOTTOM"));
-
-        Slab topSlab = (Slab) Material.END_STONE_BRICK_SLAB.createBlockData();
-        topSlab.setType(Slab.Type.TOP);
-        addPixel(topSlab, 0, 8, 0, 16, 8, 16, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_SLAB", Material.END_STONE_BRICK_SLAB, "LAUFBAU_TYPE_TOP"));
-
-        SeaPickle quadSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
-        quadSeaPickle.setWaterlogged(false);
-        quadSeaPickle.setPickles(4);
-        addPixel(quadSeaPickle, 2, 0, 2, 12, 7, 12, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_4"));
-
-        Campfire campfire = (Campfire) Material.CAMPFIRE.createBlockData();
-        campfire.setSignalFire(false);
-        campfire.setLit(false);
-        addPixel(campfire, 0, 0, 0, 16, 7, 16, createItem("LAUFBAU_BLOCK_CAMPFIRE", Material.CAMPFIRE));
-
-        SeaPickle trippleSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
-        trippleSeaPickle.setWaterlogged(false);
-        trippleSeaPickle.setPickles(3);
-        addPixel(trippleSeaPickle, 2, 0, 2, 12, 6, 12, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_3"));
-
-        SeaPickle doubleSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
-        doubleSeaPickle.setWaterlogged(false);
-        doubleSeaPickle.setPickles(2);
-        addPixel(doubleSeaPickle, 3, 0, 3, 10, 6, 10, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_2"));
-
-        SeaPickle singleSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
-        singleSeaPickle.setWaterlogged(false);
-        singleSeaPickle.setPickles(1);
-        addPixel(singleSeaPickle, 6, 0, 6, 4, 6, 4, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_1"));
-
-        addPixel(Material.FLOWER_POT.createBlockData(), 5, 0, 5, 6, 6, 6, createItem("LAUFBAU_BLOCK_FLOWER_POT", Material.FLOWER_POT));
-
-        Snow snowLayers3 = (Snow) Material.SNOW.createBlockData();
-        snowLayers3.setLayers(3);
-        addPixel(snowLayers3, 0, 0, 0, 16, 4, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_3"));
-
-        TrapDoor bottomTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
-        bottomTrapDoor.setHalf(Bisected.Half.BOTTOM);
-        addPixel(bottomTrapDoor, 0, 0, 0, 16, 3, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_HALF_BOTTOM"));
-
-        TrapDoor topTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
-        topTrapDoor.setHalf(Bisected.Half.TOP);
-        addPixel(topTrapDoor, 0, 13, 0, 16, 3, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_HALF_TOP"));
-
-        Snow snowLayers2 = (Snow) Material.SNOW.createBlockData();
-        snowLayers2.setLayers(2);
-        addPixel(snowLayers2, 0, 0, 0, 16, 2, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_2"));
-
-        addPixel(Material.LILY_PAD.createBlockData(), 1, 0, 1, 14, 1.5, 14, createItem("LAUFBAU_BLOCK_LILY_PAD", Material.LILY_PAD));
-        addPixel(Material.WHITE_CARPET.createBlockData(), 0, 0, 0, 16, 1, 16, createItem("LAUFBAU_BLOCK_WHITE_CARPET", Material.WHITE_CARPET));
-
-        Directional endRodBottomTop = (Directional) Material.END_ROD.createBlockData();
-        endRodBottomTop.setFacing(BlockFace.UP);
-        addPixel(endRodBottomTop, 6, 0, 6, 4, 16, 4, createItem("LAUFBAU_BLOCK_END_ROD", Material.END_ROD, "LAUFBAU_FACING_UP", "LAUFBAU_FACING_DOWN"));
-
-        Directional endRodNorthSouth = (Directional) Material.END_ROD.createBlockData();
-        endRodNorthSouth.setFacing(BlockFace.NORTH);
-        addPixel(endRodNorthSouth, 6, 6, 0, 4, 4, 16, createItem("LAUFBAU_BLOCK_END_ROD", Material.END_ROD, "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
-
-        Directional endRodEastWest = (Directional) Material.END_ROD.createBlockData();
-        endRodEastWest.setFacing(BlockFace.EAST);
-        addPixel(endRodEastWest, 0, 6, 6, 16, 4, 4, createItem("LAUFBAU_BLOCK_END_ROD", Material.END_ROD, "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
-
-        Directional lightningRodBottomTop = (Directional) Material.LIGHTNING_ROD.createBlockData();
-        lightningRodBottomTop.setFacing(BlockFace.UP);
-        addPixel(lightningRodBottomTop, 6, 0, 6, 4, 16, 4, createItem("LAUFBAU_BLOCK_LIGHTNING_ROD", Material.LIGHTNING_ROD, "LAUFBAU_FACING_UP", "LAUFBAU_FACING_DOWN"));
-
-        Directional lightningRodNorthSouth = (Directional) Material.LIGHTNING_ROD.createBlockData();
-        lightningRodNorthSouth.setFacing(BlockFace.NORTH);
-        addPixel(lightningRodNorthSouth, 6, 6, 0, 4, 4, 16, createItem("LAUFBAU_BLOCK_LIGHTNING_ROD", Material.LIGHTNING_ROD, "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
-
-        Directional lightningRodEastWest = (Directional) Material.LIGHTNING_ROD.createBlockData();
-        lightningRodEastWest.setFacing(BlockFace.EAST);
-        addPixel(lightningRodEastWest, 0, 6, 6, 16, 4, 4, createItem("LAUFBAU_BLOCK_LIGHTNING_ROD", Material.LIGHTNING_ROD, "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
-
-        Waterlogged conduit = (Waterlogged) Material.CONDUIT.createBlockData();
-        conduit.setWaterlogged(false);
-        addPixel(conduit, 5, 5, 5, 6, 6, 6, createItem("LAUFBAU_BLOCK_CONDUIT", Material.CONDUIT));
-
-        TrapDoor northTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
-        northTrapDoor.setFacing(BlockFace.NORTH);
-        northTrapDoor.setOpen(true);
-        addPixel(northTrapDoor, 0, 0, 13, 16, 16, 3, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_NORTH", "LAUFBAU_OPEN"));
-
-        TrapDoor southTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
-        southTrapDoor.setFacing(BlockFace.SOUTH);
-        southTrapDoor.setOpen(true);
-        addPixel(southTrapDoor, 0, 0, 0, 16, 16, 3, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_SOUTH", "LAUFBAU_OPEN"));
-
-        TrapDoor westTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
-        westTrapDoor.setFacing(BlockFace.WEST);
-        westTrapDoor.setOpen(true);
-        addPixel(westTrapDoor, 13, 0, 0, 3, 16, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_WEST", "LAUFBAU_OPEN"));
-
-        TrapDoor eastTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
-        eastTrapDoor.setFacing(BlockFace.EAST);
-        eastTrapDoor.setOpen(true);
-        addPixel(eastTrapDoor, 0, 0, 0, 3, 16, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_EAST", "LAUFBAU_OPEN"));
-    }
-
-    private static void addPixel(BlockData blockData, double xPixel, double yPixel, double zPixel, double dxPixel, double dyPixel, double dzPixel, SWItem swItem) {
-        new BlockBoundingBox(blockData, Arrays.asList(pixelCuboid(xPixel, yPixel, zPixel, dxPixel, dyPixel, dzPixel)), swItem);
-    }
-
-    private static void addPixel(BlockData blockData, double xPixel, double yPixel, double zPixel, double dxPixel, double dyPixel, double dzPixel, SWItem swItem, Consumer<BaseBlock> blockConsumer) {
-        new BlockBoundingBox(blockData, Arrays.asList(pixelCuboid(xPixel, yPixel, zPixel, dxPixel, dyPixel, dzPixel)), swItem, blockConsumer);
-    }
-
-    @SuppressWarnings("deprecation")
-    private static void randomPlayerHead(BaseBlock block) {
-        if (block instanceof SkullBlock) {
-            SkullBlock skullBlock = (SkullBlock) block;
-            skullBlock.setOwner(randomPlayerHead.get(random.nextInt(randomPlayerHead.size())).toString());
-        }
-    }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/Cuboid.java

@@ -22,6 +22,7 @@ package de.steamwar.bausystem.features.slaves.laufbau;
 import de.steamwar.bausystem.region.Point;
 import lombok.AllArgsConstructor;
 import lombok.Data;
+import org.bukkit.util.BoundingBox;
 
 @Data
 @AllArgsConstructor
@@ -33,6 +34,15 @@ public class Cuboid {
     private double dy;
     private double dz;
 
+    public Cuboid(BoundingBox boundingBox) {
+        this.x = boundingBox.getMinX();
+        this.y = boundingBox.getMinY();
+        this.z = boundingBox.getMinZ();
+        this.dx = boundingBox.getWidthX();
+        this.dy = boundingBox.getHeight();
+        this.dz = boundingBox.getWidthZ();
+    }
+
     public boolean intersects(Cuboid cuboid) {
         double minx = x - cuboid.dx;
         double miny = y - cuboid.dy;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/Laufbau.java

@@ -29,11 +29,15 @@ import org.bukkit.World;
 import org.bukkit.entity.Player;
 import org.bukkit.util.Vector;
 
+import java.util.Comparator;
 import java.util.List;
 import java.util.stream.Collectors;
 
 public class Laufbau {
 
+    private static final Comparator<BlockBoundingBox> BLAST_RESISTANCE = Comparator.comparingDouble(value -> -value.material.getBlastResistance());
+    private static final Comparator<BlockBoundingBox> VOLUME = Comparator.comparingDouble(value -> -value.volume());
+
     private World world;
     private Location pos1;
     private Location pos2;
@@ -61,26 +65,10 @@ public class Laufbau {
         editSession = WorldEditUtils.getEditSession(player);
 
         elements = BlockBoundingBox.elements.stream().filter(blockBoundingBox -> {
-            return !LaufbauUtils.isDeactivated(player, blockBoundingBox);
+            return !LaufbauConfig.STORE.get(player).getDeactivated().contains(blockBoundingBox.getMaterial());
         }).collect(Collectors.toList());
-        if (preferingBlastResistance) {
-            elements.sort((o1, o2) -> {
-                int compared = Double.compare(o1.blockData.getMaterial().getBlastResistance(), o2.blockData.getMaterial().getBlastResistance());
-                if (compared != 0) {
-                    return -compared;
-                }
-                return -Double.compare(o1.volume(), o2.volume());
-            });
-        } else {
-            elements.sort((o1, o2) -> {
-                int compared = Double.compare(o1.volume(), o2.volume());
-                if (compared != 0) {
-                    return -compared;
-                }
-                return -Double.compare(o1.blockData.getMaterial().getBlastResistance(), o2.blockData.getMaterial().getBlastResistance());
-            });
-        }
 
+        elements.sort(preferingBlastResistance ? BLAST_RESISTANCE.thenComparing(VOLUME) : VOLUME.thenComparing(BLAST_RESISTANCE));
         active = new ProcessingTracesState(world, this::inRegion, editSession, elements, factor);
     }
 
@@ -107,19 +95,8 @@ public class Laufbau {
     }
 
     private boolean inRegion(Vector location, int expansion) {
-        if (location.getBlockX() >= pos1.getBlockX() - expansion) {
-            if (location.getBlockY() >= pos1.getBlockY() - expansion) {
-                if (location.getBlockZ() >= pos1.getBlockZ() - expansion) {
-                    if (location.getBlockX() <= pos2.getBlockX() + expansion) {
-                        if (location.getBlockY() <= pos2.getBlockY() + expansion) {
-                            if (location.getBlockZ() <= pos2.getBlockZ() + expansion) {
-                                return true;
-                            }
-                        }
-                    }
-                }
-            }
-        }
-        return false;
+        return location.getBlockX() >= pos1.getBlockX() - expansion && location.getBlockX() <= pos2.getBlockX() + expansion
+                && location.getBlockY() >= pos1.getBlockY() - expansion && location.getBlockY() <= pos2.getBlockY() + expansion
+                && location.getBlockZ() >= pos1.getBlockZ() - expansion && location.getBlockZ() <= pos2.getBlockZ() + expansion;
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/LaufbauConfig.java

@@ -0,0 +1,59 @@
+/*
+ *   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.laufbau;
+
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+import org.bukkit.Material;
+
+import java.util.HashSet;
+import java.util.Set;
+
+/**
+ * The current laufbau config of a player. It is stored as JSON, fields missing
+ * in the stored JSON keep the default value of their initializer, so adding a
+ * new field does not need a new version.
+ * <p>
+ * When a field gets removed, renamed or its meaning changes, copy this class
+ * to LaufbauConfigV{@link #VERSION} (without the {@link #STORE}), increase {@link #VERSION}, write a
+ * {@link de.steamwar.bausystem.config.ConfigConverter} from the copy to
+ * this class and register it in the {@link #STORE}.
+ */
+@Getter
+@Setter
+public class LaufbauConfig implements VersionedConfig {
+
+    public static final int VERSION = 3;
+
+    public static final ConfigStore<LaufbauConfig> STORE = new ConfigStore<>(LaufbauConfig.class, VERSION, LaufbauConfig::new)
+            .userConfig("bausystem-laufbau")
+            .removeIf(config -> config.getDeactivated().isEmpty());
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Materials of the deactivated {@link BlockBoundingBox}es
+     */
+    protected Set<Material> deactivated = new HashSet<>();
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/LaufbauSettings.java

@@ -21,7 +21,6 @@ package de.steamwar.bausystem.features.slaves.laufbau;
 
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.shared.Pair;
-import de.steamwar.data.CMDs;
 import de.steamwar.inventory.SWItem;
 import de.steamwar.inventory.SWListInv;
 import org.bukkit.Material;
@@ -32,13 +31,11 @@ import java.util.*;
 
 public class LaufbauSettings {
 
-    private static Map<Pair<Material, String>, List<BlockBoundingBox>> groupMap = new LinkedHashMap<>();
+    private static Set<Pair<Material, String>> groups = new LinkedHashSet<>();
 
     static {
         BlockBoundingBox.elements.forEach(blockBoundingBox -> {
-            if (blockBoundingBox.getSwItem() == null) return;
-            String displayName = blockBoundingBox.getSwItem().getItemMeta().getDisplayName();
-            groupMap.computeIfAbsent(new Pair<>(blockBoundingBox.getSwItem().getItemStack().getType(), displayName), k -> new ArrayList<>()).add(blockBoundingBox);
+            groups.add(new Pair<>(blockBoundingBox.getMaterial(), blockBoundingBox.getName()));
         });
     }
 
@@ -50,96 +47,35 @@ public class LaufbauSettings {
     }
 
     public void open() {
-        List<SWListInv.SWListEntry<Map.Entry<Pair<Material, String>, List<BlockBoundingBox>>>> list = new ArrayList<>();
-        for (Map.Entry<Pair<Material, String>, List<BlockBoundingBox>> entry : groupMap.entrySet()) {
-            SWItem swItem = createItem(entry.getKey().getKey(), entry.getKey().getValue(), entry.getValue());
-            list.add(new SWListInv.SWListEntry<>(swItem, entry));
+        List<SWListInv.SWListEntry<Pair<Material, String>>> list = new ArrayList<>();
+        for (Pair<Material, String> group : groups) {
+            list.add(new SWListInv.SWListEntry<>(createItem(group.getKey(), group.getValue()), group));
         }
-        SWListInv<Map.Entry<Pair<Material, String>, List<BlockBoundingBox>>> inv = new SWListInv<>(p, BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_GUI_NAME", p), false, list, (clickType, entry) -> {
-            if (entry.getValue().size() == 1) {
-                LaufbauUtils.toggle(p, entry.getValue().get(0));
-                open();
-                return;
-            }
-            if (clickType.isLeftClick()) {
-                open(entry.getKey());
-                return;
-            }
-            toggle(entry.getValue());
+        SWListInv<Pair<Material, String>> inv = new SWListInv<>(p, BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_GUI_NAME", p), false, list, (clickType, group) -> {
+            toggle(group.getKey());
             open();
         });
         inv.open();
     }
 
-    public void open(Pair<Material, String> key) {
-        List<BlockBoundingBox> blockBoundingBoxes = groupMap.get(key);
-        List<SWListInv.SWListEntry<BlockBoundingBox>> list = new ArrayList<>();
-        for (BlockBoundingBox bb : blockBoundingBoxes) {
-            SWItem swItem = LaufbauUtils.translateItem(bb.getSwItem(), p);
-            ItemMeta itemMeta = swItem.getItemMeta();
-            List<String> lore = new ArrayList<>();
-            if (itemMeta.getLore() != null) {
-                lore = itemMeta.getLore();
-            }
-            lore.add("");
-            lore.add(BauSystem.MESSAGE.parse(LaufbauUtils.isDeactivated(p, bb) ? "LAUFBAU_SETTINGS_INACTIVE" : "LAUFBAU_SETTINGS_ACTIVE", p));
-            itemMeta.setLore(lore);
-            swItem.setItemMeta(itemMeta);
-            list.add(new SWListInv.SWListEntry<>(swItem, bb));
+    public SWItem createItem(Material material, String name) {
+        SWItem swItem = new SWItem(material, name);
+        ItemMeta itemMeta = swItem.getItemMeta();
+        List<String> lore = new ArrayList<>();
+        if (itemMeta != null && itemMeta.getLore() != null) {
+            lore = itemMeta.getLore();
         }
-        SWListInv<BlockBoundingBox> inv = new SWListInv<>(p, BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_GUI_NAME", p), false, list, (clickType, blockBoundingBox) -> {
-            LaufbauUtils.toggle(p, blockBoundingBox);
-            open(key);
-        });
-        inv.setItem(49, new SWItem(Material.ARROW, BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_GUI_BACK", p), clickType -> {
-            open();
-        }).setCustomModelData(CMDs.BACK));
-        inv.open();
+        lore.add("");
+        lore.add(BauSystem.MESSAGE.parse(LaufbauConfig.STORE.get(p).getDeactivated().contains(material) ? "LAUFBAU_SETTINGS_INACTIVE" : "LAUFBAU_SETTINGS_ACTIVE", p));
+        lore.add("");
+        lore.add(BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_TOGGLE", p));
+        if (itemMeta != null) itemMeta.setLore(lore);
+        swItem.setItemMeta(itemMeta);
+        return swItem;
     }
 
-    public SWItem createItem(Material material, String group, List<BlockBoundingBox> blockBoundingBoxes) {
-        if (blockBoundingBoxes.size() == 1) {
-            BlockBoundingBox bb = blockBoundingBoxes.get(0);
-            SWItem swItem = LaufbauUtils.translateItem(bb.getSwItem(), p);
-            ItemMeta itemMeta = swItem.getItemMeta();
-            List<String> lore = new ArrayList<>();
-            if (itemMeta.getLore() != null) {
-                lore = itemMeta.getLore();
-            }
-            lore.add("");
-            lore.add(BauSystem.MESSAGE.parse(LaufbauUtils.isDeactivated(p, bb) ? "LAUFBAU_SETTINGS_INACTIVE" : "LAUFBAU_SETTINGS_ACTIVE", p));
-            lore.add("");
-            lore.add(BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_TOGGLE", p));
-            itemMeta.setLore(lore);
-            swItem.setItemMeta(itemMeta);
-            return swItem;
-        } else {
-            long count = blockBoundingBoxes.stream().filter(bb -> LaufbauUtils.isDeactivated(p, bb)).count();
-            if (count == 0) {
-                return new SWItem(material, BauSystem.MESSAGE.parse(group, p), Arrays.asList("", BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_ACTIVE", p), "", BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_ADVANCED", p), BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_TOGGLE", p)), false, clickType -> {
-                });
-            }
-            if (count == blockBoundingBoxes.size()) {
-                return new SWItem(material, BauSystem.MESSAGE.parse(group, p), Arrays.asList("", BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_INACTIVE", p), "", BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_ADVANCED", p), BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_TOGGLE", p)), false, clickType -> {
-                });
-            }
-            return new SWItem(material, BauSystem.MESSAGE.parse(group, p), Arrays.asList("", BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_MIXED", p, blockBoundingBoxes.size() - count, blockBoundingBoxes.size()), "", BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_ADVANCED", p), BauSystem.MESSAGE.parse("LAUFBAU_SETTINGS_TOGGLE", p)), false, clickType -> {
-            });
-        }
-    }
-
-    public void toggle(List<BlockBoundingBox> blockBoundingBoxes) {
-        long count = blockBoundingBoxes.stream().filter(bb -> LaufbauUtils.isDeactivated(p, bb)).count();
-        if (count != blockBoundingBoxes.size()) {
-            blockBoundingBoxes.forEach(bb -> {
-                if (!LaufbauUtils.isDeactivated(p, bb)) {
-                    LaufbauUtils.toggle(p, bb);
-                }
-            });
-        } else {
-            blockBoundingBoxes.forEach(bb -> {
-                LaufbauUtils.toggle(p, bb);
-            });
-        }
+    public void toggle(Material material) {
+        Set<Material> deactivated = LaufbauConfig.STORE.get(p).getDeactivated();
+        if (!deactivated.remove(material)) deactivated.add(material);
     }
 }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/LaufbauUtils.java

@@ -1,142 +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.slaves.laufbau;
-
-import de.steamwar.bausystem.BauSystem;
-import de.steamwar.core.SWPlayer;
-import de.steamwar.inventory.SWItem;
-import de.steamwar.sql.UserConfig;
-import lombok.Cleanup;
-import lombok.SneakyThrows;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Material;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.meta.ItemMeta;
-import yapion.hierarchy.output.StreamOutput;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.YAPIONParser;
-import yapion.parser.options.StreamOptions;
-
-import java.io.ByteArrayInputStream;
-import java.io.ByteArrayOutputStream;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.Base64;
-import java.util.List;
-import java.util.stream.Collectors;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-@UtilityClass
-public class LaufbauUtils {
-
-    public static class LaufbauComponent implements SWPlayer.Component {
-
-        private YAPIONObject yapionObject = new YAPIONObject();
-
-        @Override
-        @SneakyThrows
-        public void onMount(SWPlayer player) {
-            String config = UserConfig.getConfig(player.getPlayer().getUniqueId(), "bausystem-laufbau");
-            if (config == null) {
-                return;
-            }
-            byte[] bytes = Base64.getDecoder().decode(config);
-            @Cleanup GZIPInputStream gzipInputStream = new GZIPInputStream(new ByteArrayInputStream(bytes));
-            yapionObject = new YAPIONParser(gzipInputStream, new StreamOptions().stopOnStreamEnd(true)).parse().result();
-        }
-
-        @Override
-        @SneakyThrows
-        public void onUnmount(SWPlayer player) {
-            if (yapionObject.isEmpty()) {
-                UserConfig.removePlayerConfig(player.getPlayer().getUniqueId(), "bausystem-laufbau");
-                return;
-            }
-            @Cleanup ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
-            @Cleanup GZIPOutputStream gzipOutputStream = new GZIPOutputStream(byteArrayOutputStream);
-            yapionObject.toYAPION(new StreamOutput(gzipOutputStream)).close();
-            UserConfig.updatePlayerConfig(player.getPlayer().getUniqueId(), "bausystem-laufbau", Base64.getEncoder().encodeToString(byteArrayOutputStream.toByteArray()));
-        }
-    }
-
-    public static Cuboid pixelCuboid(double pixelX, double pixelY, double pixelZ, double pixelDX, double pixelDY, double pixelDZ) {
-        return new Cuboid(pixelToBlock(pixelX), pixelToBlock(pixelY), pixelToBlock(pixelZ), pixelToBlock(pixelDX), pixelToBlock(pixelDY), pixelToBlock(pixelDZ));
-    }
-
-    public static double pixelToBlock(double pixel) {
-        return 1.0 / 16 * pixel;
-    }
-
-    public static SWItem createItem(String name, Material material, String... lore) {
-        return new SWItem(material, name, Arrays.asList(lore), false, clickType -> {
-        });
-    }
-
-    public static SWItem translateItem(SWItem item, Player p) {
-        ItemMeta itemMeta = item.getItemMeta();
-        List<String> lore = new ArrayList<>();
-        if (itemMeta.getLore() != null) {
-            lore = itemMeta.getLore().stream().map(s -> BauSystem.MESSAGE.parse(s, p)).collect(Collectors.toList());
-        }
-        return new SWItem(item.getItemStack().getType(), BauSystem.MESSAGE.parse(itemMeta.getDisplayName(), p), lore, false, clickType -> {
-        });
-    }
-
-    public static String identifier(BlockBoundingBox bb) {
-        if (bb.getSwItem() == null) {
-            return null;
-        }
-        SWItem item = bb.getSwItem();
-        ItemMeta itemMeta = item.getItemMeta();
-        List<String> lore = new ArrayList<>();
-        if (itemMeta.getLore() != null) {
-            lore = itemMeta.getLore()
-                    .stream()
-                    .map(s -> s.substring(8))
-                    .collect(Collectors.toList());
-        }
-        String name = itemMeta.getDisplayName().substring(14);
-        return name + "[" + String.join(",", lore) + "]";
-    }
-
-    @SneakyThrows
-    public static boolean isDeactivated(Player p, BlockBoundingBox bb) {
-        if (bb.getSwItem() == null) {
-            return false;
-        }
-        String identifier = identifier(bb);
-        return SWPlayer.of(p).getComponentOrDefault(LaufbauComponent.class, LaufbauComponent::new).yapionObject.containsKey(identifier);
-    }
-
-    @SneakyThrows
-    public static void toggle(Player p, BlockBoundingBox bb) {
-        if (bb.getSwItem() == null) {
-            return;
-        }
-        String identifier = identifier(bb);
-        YAPIONObject yapionObject = SWPlayer.of(p).getComponentOrDefault(LaufbauComponent.class, LaufbauComponent::new).yapionObject;
-        if (yapionObject.containsKey(identifier)) {
-            yapionObject.remove(identifier);
-        } else {
-            yapionObject.put(identifier, new YAPIONObject());
-        }
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/AmethystBoundingBox.java

@@ -1,261 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.AmethystCluster;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class AmethystBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        floorSmallAmethystBud();
-        ceilingSmallAmethystBud();
-        northSmallAmethystBud();
-        southSmallAmethystBud();
-        eastSmallAmethystBud();
-        westSmallAmethystBud();
-
-        floorMediumAmethystBud();
-        ceilingMediumAmethystBud();
-        northMediumAmethystBud();
-        southMediumAmethystBud();
-        eastMediumAmethystBud();
-        westMediumAmethystBud();
-
-        floorLargeAmethystBud();
-        ceilingLargeAmethystBud();
-        northLargeAmethystBud();
-        southLargeAmethystBud();
-        eastLargeAmethystBud();
-        westLargeAmethystBud();
-
-        floorAmethystCluster();
-        ceilingAmethystCluster();
-        northAmethystCluster();
-        southAmethystCluster();
-        eastAmethystCluster();
-        westAmethystCluster();
-    }
-
-    private void floorSmallAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.UP);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 0, 4, 8, 3, 8));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_UP"));
-    }
-
-    private void ceilingSmallAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.DOWN);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 13, 4, 8, 3, 8));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_DOWN"));
-    }
-
-    private void northSmallAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 13, 8, 8, 3));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_NORTH"));
-    }
-
-    private void southSmallAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 0, 8, 8, 3));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_SOUTH"));
-    }
-
-    private void eastSmallAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 4, 4, 3, 8, 8));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_EAST"));
-    }
-
-    private void westSmallAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(13, 4, 4, 3, 8, 8));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_WEST"));
-    }
-
-    private void floorMediumAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.UP);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 0, 3, 10, 4, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_UP"));
-    }
-
-    private void ceilingMediumAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.DOWN);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 12, 3, 10, 4, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_DOWN"));
-    }
-
-    private void northMediumAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 3, 12, 10, 10, 4));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_NORTH"));
-    }
-
-    private void southMediumAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 4));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_SOUTH"));
-    }
-
-    private void eastMediumAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 3, 3, 4, 10, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_EAST"));
-    }
-
-    private void westMediumAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(12, 3, 3, 4, 10, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_WEST"));
-    }
-
-    private void floorLargeAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.UP);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 0, 3, 10, 5, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_UP"));
-    }
-
-    private void ceilingLargeAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.DOWN);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 11, 3, 10, 5, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_DOWN"));
-    }
-
-    private void northLargeAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 3, 11, 10, 10, 5));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_NORTH"));
-    }
-
-    private void southLargeAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 5));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_SOUTH"));
-    }
-
-    private void eastLargeAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 3, 3, 5, 10, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_EAST"));
-    }
-
-    private void westLargeAmethystBud() {
-        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
-        cluster.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(11, 3, 3, 5, 10, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_WEST"));
-    }
-
-    private void floorAmethystCluster() {
-        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
-        cluster.setFacing(BlockFace.UP);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 0, 3, 10, 7, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_UP"));
-    }
-
-    private void ceilingAmethystCluster() {
-        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
-        cluster.setFacing(BlockFace.DOWN);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 9, 3, 10, 7, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_DOWN"));
-    }
-
-    private void northAmethystCluster() {
-        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
-        cluster.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 3, 9, 10, 10, 7));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_NORTH"));
-    }
-
-    private void southAmethystCluster() {
-        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
-        cluster.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 7));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_SOUTH"));
-    }
-
-    private void eastAmethystCluster() {
-        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
-        cluster.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 3, 3, 7, 10, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_EAST"));
-    }
-
-    private void westAmethystCluster() {
-        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
-        cluster.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(9, 3, 3, 7, 10, 10));
-        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_WEST"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/AzaleaBoundingBox.java

@@ -1,46 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.BlockData;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class AzaleaBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        BlockData blockData = Material.FLOWERING_AZALEA.createBlockData();
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(6, 0, 6, 4, 8, 4));
-        new BlockBoundingBox(blockData, cuboidList, createItem("LAUFBAU_BLOCK_AZALEA", Material.FLOWERING_AZALEA));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/BellBoundingBox.java

@@ -1,149 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.Bell;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class BellBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        ceilingBell();
-
-        floorNorthBell();
-        floorEastBell();
-
-        doubleWallNorthBell();
-        doubleWallEastBell();
-
-        singleWallNorthBell();
-        singleWallSouthBell();
-        singleWallEastBell();
-        singleWallWestBell();
-    }
-
-    public void ceilingBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.CEILING);
-        bell.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(7, 13, 7, 2, 3, 2));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_CEILING"));
-    }
-
-    public void floorNorthBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.FLOOR);
-        bell.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 4, 16, 16, 8));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void floorEastBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.FLOOR);
-        bell.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 0, 0, 8, 16, 16));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void doubleWallNorthBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.DOUBLE_WALL);
-        bell.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(7, 13, 0, 2, 2, 16));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_DOUBLE_WALL", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void doubleWallEastBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.DOUBLE_WALL);
-        bell.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(0, 13, 7, 16, 2, 2));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_DOUBLE_WALL", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void singleWallNorthBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
-        bell.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(7, 13, 0, 2, 2, 13));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void singleWallSouthBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
-        bell.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(7, 13, 3, 2, 2, 13));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void singleWallEastBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
-        bell.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(3, 13, 7, 13, 2, 2));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void singleWallWestBell() {
-        Bell bell = (Bell) Material.BELL.createBlockData();
-        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
-        bell.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
-        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
-        cuboidList.add(pixelCuboid(0, 13, 7, 13, 2, 2));
-        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_WEST"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/BrewingStandBoundingBox.java

@@ -1,46 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.type.BrewingStand;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class BrewingStandBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        BrewingStand brewingStand = (BrewingStand) Material.BREWING_STAND.createBlockData();
-        List<Cuboid> cuboids = new ArrayList<>();
-        cuboids.add(pixelCuboid(1, 0, 1, 14, 2, 14));
-        cuboids.add(pixelCuboid(7, 2, 7, 2, 12, 2));
-        new BlockBoundingBox(brewingStand, cuboids, createItem("LAUFBAU_BLOCK_BREWING_STAND", Material.BREWING_STAND));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/CandleBoundingBox.java

@@ -1,62 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.Lightable;
-import org.bukkit.block.data.type.Candle;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class CandleBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        caked();
-
-        single();
-    }
-
-    private void caked() {
-        Lightable candleCake = (Lightable) Material.CYAN_CANDLE_CAKE.createBlockData();
-        candleCake.setLit(true);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(7, 8, 7, 2, 6, 2));
-        new BlockBoundingBox(candleCake, cuboidList, createItem("LAUFBAU_BLOCK_CANDLE_CAKE", Material.CAKE));
-    }
-
-    private void single() {
-        Candle candle = (Candle) Material.CYAN_CANDLE.createBlockData();
-        candle.setCandles(1);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(7, 0, 7, 2, 6, 2));
-        new BlockBoundingBox(candle, cuboidList, createItem("LAUFBAU_BLOCK_CANDLE", Material.CYAN_CANDLE, "LAUFBAU_COUNT_1"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/ChainBoundingBox.java

@@ -1,69 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Axis;
-import org.bukkit.Material;
-import org.bukkit.block.data.Orientable;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class ChainBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        bottomTopChain();
-        northSouthChain();
-        eastWestChain();
-    }
-
-    private void bottomTopChain() {
-        Orientable chainBottomTop = (Orientable) Material.CHAIN.createBlockData();
-        chainBottomTop.setAxis(Axis.Y);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(6.5, 0, 6.5, 3, 16, 3));
-        new BlockBoundingBox(chainBottomTop, cuboidList, createItem("LAUFBAU_BLOCK_CHAIN", Material.CHAIN, "LAUFBAU_FACING_UP", "LAUFBAU_FACING_DOWN"));
-    }
-
-    private void northSouthChain() {
-        Orientable chainBottomTop = (Orientable) Material.CHAIN.createBlockData();
-        chainBottomTop.setAxis(Axis.Z);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(6.5, 6.5, 0, 3, 3, 16));
-        new BlockBoundingBox(chainBottomTop, cuboidList, createItem("LAUFBAU_BLOCK_CHAIN", Material.CHAIN, "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    private void eastWestChain() {
-        Orientable chainBottomTop = (Orientable) Material.CHAIN.createBlockData();
-        chainBottomTop.setAxis(Axis.X);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 6.5, 6.5, 16, 3, 3));
-        new BlockBoundingBox(chainBottomTop, cuboidList, createItem("LAUFBAU_BLOCK_CHAIN", Material.CHAIN, "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/ChorusPlantBoundingBox.java

@@ -1,89 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.MultipleFacing;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class ChorusPlantBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        for (int nx = 0; nx < 2; nx++) {
-            for (int ny = 0; ny < 2; ny++) {
-                for (int nz = 0; nz < 2; nz++) {
-                    for (int px = 0; px < 2; px++) {
-                        for (int py = 0; py < 2; py++) {
-                            for (int pz = 0; pz < 2; pz++) {
-                                MultipleFacing chorusPlant = (MultipleFacing) Material.CHORUS_PLANT.createBlockData();
-                                List<String> lore = new ArrayList<>();
-                                List<Cuboid> cuboidList = new ArrayList<>();
-                                cuboidList.add(pixelCuboid(3, 3, 3, 10, 10, 10));
-                                if (nx == 1) {
-                                    lore.add("LAUFBAU_CONNECTION_WEST");
-                                    chorusPlant.setFace(BlockFace.WEST, true);
-                                    cuboidList.add(pixelCuboid(0, 3, 3, 3, 10, 10));
-                                }
-                                if (ny == 1) {
-                                    lore.add("LAUFBAU_CONNECTION_DOWN");
-                                    chorusPlant.setFace(BlockFace.DOWN, true);
-                                    cuboidList.add(pixelCuboid(3, 0, 3, 10, 3, 10));
-                                }
-                                if (nz == 1) {
-                                    lore.add("LAUFBAU_CONNECTION_NORTH");
-                                    chorusPlant.setFace(BlockFace.NORTH, true);
-                                    cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 3));
-                                }
-                                if (px == 1) {
-                                    lore.add("LAUFBAU_CONNECTION_EAST");
-                                    chorusPlant.setFace(BlockFace.EAST, true);
-                                    cuboidList.add(pixelCuboid(13, 3, 3, 3, 10, 10));
-                                }
-                                if (py == 1) {
-                                    lore.add("LAUFBAU_CONNECTION_UP");
-                                    chorusPlant.setFace(BlockFace.UP, true);
-                                    cuboidList.add(pixelCuboid(3, 13, 3, 10, 3, 10));
-                                }
-                                if (pz == 1) {
-                                    lore.add("LAUFBAU_CONNECTION_SOUTH");
-                                    chorusPlant.setFace(BlockFace.SOUTH, true);
-                                    cuboidList.add(pixelCuboid(3, 3, 13, 10, 10, 3));
-                                }
-                                new BlockBoundingBox(chorusPlant, cuboidList, createItem("LAUFBAU_BLOCK_CHORUS_PLANT", Material.CHORUS_PLANT, lore.toArray(new String[0])));
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/DragonEggBoundingBox.java

@@ -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/>.
- */
-
-package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.BlockData;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class DragonEggBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        BlockData blockData = Material.DRAGON_EGG.createBlockData();
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(1, 0, 1, 14, 16, 14));
-        new BlockBoundingBox(blockData, cuboidList, createItem("LAUFBAU_BLOCK_DRAGON_EGG", Material.DRAGON_EGG));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/DripLeafBoundingBox.java

@@ -1,59 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.type.BigDripleaf;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class DripLeafBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        tiltNone();
-        tiltPartial();
-    }
-
-    private void tiltNone() {
-        BigDripleaf bigDripleaf = (BigDripleaf) Material.BIG_DRIPLEAF.createBlockData();
-        bigDripleaf.setTilt(BigDripleaf.Tilt.NONE);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 11, 0, 16, 4, 16));
-        new BlockBoundingBox(bigDripleaf, cuboidList, createItem("LAUFBAU_BLOCK_BIG_DRIP_LEAF", Material.BIG_DRIPLEAF, "LAUFBAU_TILT_NONE"));
-    }
-
-    private void tiltPartial() {
-        BigDripleaf bigDripleaf = (BigDripleaf) Material.BIG_DRIPLEAF.createBlockData();
-        bigDripleaf.setTilt(BigDripleaf.Tilt.PARTIAL);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 11, 0, 16, 2, 16));
-        new BlockBoundingBox(bigDripleaf, cuboidList, createItem("LAUFBAU_BLOCK_BIG_DRIP_LEAF", Material.BIG_DRIPLEAF, "LAUFBAU_TILT_PARTIAL"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/FencesBoundingBox.java

@@ -1,75 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.Fence;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class FencesBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        for (int nx = 0; nx < 2; nx++) {
-            for (int nz = 0; nz < 2; nz++) {
-                for (int px = 0; px < 2; px++) {
-                    for (int pz = 0; pz < 2; pz++) {
-                        Fence fence = (Fence) Material.NETHER_BRICK_FENCE.createBlockData();
-                        List<String> lore = new ArrayList<>();
-                        List<Cuboid> cuboidList = new ArrayList<>();
-                        cuboidList.add(pixelCuboid(6, 0, 6, 4, 24, 4));
-                        if (nz == 1) {
-                            lore.add("LAUFBAU_CONNECTION_NORTH");
-                            fence.setFace(BlockFace.NORTH, true);
-                            cuboidList.add(pixelCuboid(6, 0, 0, 4, 24, 6));
-                        }
-                        if (pz == 1) {
-                            lore.add("LAUFBAU_CONNECTION_SOUTH");
-                            fence.setFace(BlockFace.SOUTH, true);
-                            cuboidList.add(pixelCuboid(6, 0, 10, 4, 24, 6));
-                        }
-                        if (nx == 1) {
-                            lore.add("LAUFBAU_CONNECTION_WEST");
-                            fence.setFace(BlockFace.WEST, true);
-                            cuboidList.add(pixelCuboid(0, 0, 6, 6, 24, 4));
-                        }
-                        if (px == 1) {
-                            lore.add("LAUFBAU_CONNECTION_EAST");
-                            fence.setFace(BlockFace.EAST, true);
-                            cuboidList.add(pixelCuboid(10, 0, 6, 6, 24, 4));
-                        }
-                        new BlockBoundingBox(fence, cuboidList, createItem("LAUFBAU_BLOCK_NETHER_BRICK_FENCE", Material.NETHER_BRICK_FENCE, lore.toArray(new String[0])));
-                    }
-                }
-            }
-        }
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/GrindstoneBoundingBox.java

@@ -1,157 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.FaceAttachable;
-import org.bukkit.block.data.type.Grindstone;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class GrindstoneBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        floorNorthGrindstone();
-        floorEastGrindstone();
-
-        ceilingNorthGrindstone();
-        ceilingEastGrindstone();
-
-        wallNorthGrindstone();
-        wallSouthGrindstone();
-        wallEastGrindstone();
-        wallWestGrindstone();
-    }
-
-    public void floorNorthGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.FLOOR);
-        grindstone.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 4, 2, 8, 12, 12));
-        cuboidList.add(pixelCuboid(2, 0, 6, 2, 7, 4));
-        cuboidList.add(pixelCuboid(12, 0, 6, 2, 7, 4));
-        cuboidList.add(pixelCuboid(2, 7, 5, 2, 6, 6));
-        cuboidList.add(pixelCuboid(12, 7, 5, 2, 6, 6));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void floorEastGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.FLOOR);
-        grindstone.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(2, 4, 4, 12, 12, 8));
-        cuboidList.add(pixelCuboid(6, 0, 2, 4, 7, 2));
-        cuboidList.add(pixelCuboid(6, 0, 12, 4, 7, 2));
-        cuboidList.add(pixelCuboid(5, 7, 2, 6, 6, 2));
-        cuboidList.add(pixelCuboid(5, 7, 12, 6, 6, 2));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void ceilingNorthGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.CEILING);
-        grindstone.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 0, 2, 8, 12, 12));
-        cuboidList.add(pixelCuboid(2, 9, 6, 2, 7, 4));
-        cuboidList.add(pixelCuboid(12, 9, 6, 2, 7, 4));
-        cuboidList.add(pixelCuboid(2, 3, 5, 2, 6, 6));
-        cuboidList.add(pixelCuboid(12, 3, 5, 2, 6, 6));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_CEILING", "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void ceilingEastGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.CEILING);
-        grindstone.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(2, 0, 4, 12, 12, 8));
-        cuboidList.add(pixelCuboid(6, 9, 2, 4, 7, 2));
-        cuboidList.add(pixelCuboid(6, 9, 12, 4, 7, 2));
-        cuboidList.add(pixelCuboid(5, 3, 2, 6, 6, 2));
-        cuboidList.add(pixelCuboid(5, 3, 12, 6, 6, 2));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_CEILING", "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void wallNorthGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
-        grindstone.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 2, 0, 8, 12, 12));
-        cuboidList.add(pixelCuboid(2, 6, 9, 2, 4, 7));
-        cuboidList.add(pixelCuboid(12, 6, 9, 2, 4, 7));
-        cuboidList.add(pixelCuboid(2, 5, 3, 2, 6, 6));
-        cuboidList.add(pixelCuboid(12, 5, 3, 2, 6, 6));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void wallSouthGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
-        grindstone.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 2, 4, 8, 12, 12));
-        cuboidList.add(pixelCuboid(2, 6, 0, 2, 4, 7));
-        cuboidList.add(pixelCuboid(12, 6, 0, 2, 4, 7));
-        cuboidList.add(pixelCuboid(2, 5, 7, 2, 6, 6));
-        cuboidList.add(pixelCuboid(12, 5, 7, 2, 6, 6));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void wallEastGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
-        grindstone.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(4, 2, 4, 12, 12, 8));
-        cuboidList.add(pixelCuboid(0, 6, 2, 7, 4, 2));
-        cuboidList.add(pixelCuboid(0, 6, 12, 7, 4, 2));
-        cuboidList.add(pixelCuboid(7, 5, 2, 6, 6, 2));
-        cuboidList.add(pixelCuboid(7, 5, 12, 6, 6, 2));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void wallWestGrindstone() {
-        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
-        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
-        grindstone.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 2, 4, 12, 12, 8));
-        cuboidList.add(pixelCuboid(9, 6, 2, 7, 4, 2));
-        cuboidList.add(pixelCuboid(9, 6, 12, 7, 4, 2));
-        cuboidList.add(pixelCuboid(3, 5, 2, 6, 6, 2));
-        cuboidList.add(pixelCuboid(3, 5, 12, 6, 6, 2));
-        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_WEST"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/HopperBoundingBox.java

@@ -1,97 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.Hopper;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class HopperBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        downHopper();
-        northHopper();
-        southHopper();
-        eastHopper();
-        westHopper();
-    }
-
-    public void downHopper() {
-        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
-        hopper.setFacing(BlockFace.DOWN);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
-        cuboidList.add(pixelCuboid(6, 0, 6, 4, 4, 4));
-        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_FLOOR"));
-    }
-
-    public void northHopper() {
-        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
-        hopper.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
-        cuboidList.add(pixelCuboid(6, 4, 0, 4, 4, 4));
-        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_NORTH"));
-    }
-
-    public void southHopper() {
-        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
-        hopper.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
-        cuboidList.add(pixelCuboid(6, 4, 12, 4, 4, 4));
-        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_SOUTH"));
-    }
-
-    public void eastHopper() {
-        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
-        hopper.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
-        cuboidList.add(pixelCuboid(12, 4, 6, 4, 4, 4));
-        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_EAST"));
-    }
-
-    public void westHopper() {
-        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
-        hopper.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
-        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
-        cuboidList.add(pixelCuboid(0, 4, 6, 4, 4, 4));
-        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_WEST"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/IronBarBoundingBox.java

@@ -1,75 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.Fence;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class IronBarBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        for (int nx = 0; nx < 2; nx++) {
-            for (int nz = 0; nz < 2; nz++) {
-                for (int px = 0; px < 2; px++) {
-                    for (int pz = 0; pz < 2; pz++) {
-                        Fence fence = (Fence) Material.IRON_BARS.createBlockData();
-                        List<String> lore = new ArrayList<>();
-                        List<Cuboid> cuboidList = new ArrayList<>();
-                        cuboidList.add(pixelCuboid(7, 0, 7, 2, 16, 2));
-                        if (nz == 1) {
-                            lore.add("LAUFBAU_CONNECTION_NORTH");
-                            fence.setFace(BlockFace.NORTH, true);
-                            cuboidList.add(pixelCuboid(7, 0, 0, 2, 16, 7));
-                        }
-                        if (pz == 1) {
-                            lore.add("LAUFBAU_CONNECTION_SOUTH");
-                            fence.setFace(BlockFace.SOUTH, true);
-                            cuboidList.add(pixelCuboid(7, 0, 9, 2, 16, 7));
-                        }
-                        if (nx == 1) {
-                            lore.add("LAUFBAU_CONNECTION_WEST");
-                            fence.setFace(BlockFace.WEST, true);
-                            cuboidList.add(pixelCuboid(0, 0, 7, 7, 16, 2));
-                        }
-                        if (px == 1) {
-                            lore.add("LAUFBAU_CONNECTION_EAST");
-                            fence.setFace(BlockFace.EAST, true);
-                            cuboidList.add(pixelCuboid(9, 0, 7, 7, 16, 2));
-                        }
-                        new BlockBoundingBox(fence, cuboidList, createItem("LAUFBAU_BLOCK_IRON_BARS", Material.IRON_BARS, lore.toArray(new String[0])));
-                    }
-                }
-            }
-        }
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/LanternBoundingBox.java

@@ -1,61 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.type.Lantern;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class LanternBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        lantern();
-        hangingLantern();
-    }
-
-    public void lantern() {
-        Lantern lantern = (Lantern) Material.LANTERN.createBlockData();
-        lantern.setHanging(false);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(5, 0, 5, 6, 7, 6));
-        cuboidList.add(pixelCuboid(6, 7, 6, 4, 2, 4));
-        new BlockBoundingBox(lantern, cuboidList, createItem("LAUFBAU_BLOCK_LANTERN", Material.LANTERN));
-    }
-
-    public void hangingLantern() {
-        Lantern lantern = (Lantern) Material.LANTERN.createBlockData();
-        lantern.setHanging(true);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(5, 1, 5, 6, 7, 6));
-        cuboidList.add(pixelCuboid(6, 8, 6, 4, 2, 4));
-        new BlockBoundingBox(lantern, cuboidList, createItem("LAUFBAU_BLOCK_LANTERN", Material.LANTERN, "LAUFBAU_HANGING"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/LecternBoundingBox.java

@@ -1,46 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.data.BlockData;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class LecternBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        BlockData blockData = Material.LECTERN.createBlockData();
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 2, 16));
-        cuboidList.add(pixelCuboid(4, 2, 4, 8, 12, 8));
-        new BlockBoundingBox(blockData, cuboidList, createItem("LAUFBAU_BLOCK_LECTERN", Material.LECTERN));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/StairBoundingBox.java

@@ -1,343 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.Stairs;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class StairBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        straightBottomNorthStair();
-        straightBottomSouthStair();
-        straightBottomEastStair();
-        straightBottomWestStair();
-
-        straightTopNorthStair();
-        straightTopSouthStair();
-        straightTopEastStair();
-        straightTopWestStair();
-
-        outerLeftBottomNorthStair();
-        outerLeftBottomSouthStair();
-        outerLeftBottomEastStair();
-        outerLeftBottomWestStair();
-
-        outerLeftTopNorthStair();
-        outerLeftTopSouthStair();
-        outerLeftTopEastStair();
-        outerLeftTopWestStair();
-
-        innerLeftBottomNorthStair();
-        innerLeftBottomSouthStair();
-        innerLeftBottomEastStair();
-        innerLeftBottomWestStair();
-
-        innerLeftTopNorthStair();
-        innerLeftTopSouthStair();
-        innerLeftTopEastStair();
-        innerLeftTopWestStair();
-    }
-
-    public void straightBottomNorthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void straightBottomSouthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 8, 16, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void straightBottomEastStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(8, 8, 0, 8, 8, 16));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void straightBottomWestStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 0, 8, 8, 16));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void straightTopNorthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void straightTopSouthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 8, 16, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void straightTopEastStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(8, 0, 0, 8, 8, 16));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void straightTopWestStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.STRAIGHT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 0, 8, 8, 16));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void outerLeftBottomNorthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void outerLeftBottomSouthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(8, 8, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void outerLeftBottomEastStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(8, 8, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void outerLeftBottomWestStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void outerLeftTopNorthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void outerLeftTopSouthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(8, 0, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void outerLeftTopEastStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(8, 0, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void outerLeftTopWestStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.OUTER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void innerLeftBottomNorthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 8));
-        cuboidList.add(pixelCuboid(0, 8, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void innerLeftBottomSouthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 8, 16, 8, 8));
-        cuboidList.add(pixelCuboid(8, 8, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void innerLeftBottomEastStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 8));
-        cuboidList.add(pixelCuboid(8, 8, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void innerLeftBottomWestStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.BOTTOM);
-        stairs.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 8, 8, 16, 8, 8));
-        cuboidList.add(pixelCuboid(0, 8, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_WEST"));
-    }
-
-    public void innerLeftTopNorthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.NORTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 8));
-        cuboidList.add(pixelCuboid(0, 0, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_NORTH"));
-    }
-
-    public void innerLeftTopSouthStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.SOUTH);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 8, 16, 8, 8));
-        cuboidList.add(pixelCuboid(8, 0, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_SOUTH"));
-    }
-
-    public void innerLeftTopEastStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.EAST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 8));
-        cuboidList.add(pixelCuboid(8, 0, 8, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_EAST"));
-    }
-
-    public void innerLeftTopWestStair() {
-        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
-        stairs.setShape(Stairs.Shape.INNER_LEFT);
-        stairs.setHalf(Stairs.Half.TOP);
-        stairs.setFacing(BlockFace.WEST);
-        List<Cuboid> cuboidList = new ArrayList<>();
-        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
-        cuboidList.add(pixelCuboid(0, 0, 8, 16, 8, 8));
-        cuboidList.add(pixelCuboid(0, 0, 0, 8, 8, 8));
-        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_WEST"));
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/boundingboxes/WallBoundingBox.java

@@ -1,79 +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.slaves.laufbau.boundingboxes;
-
-import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
-import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
-import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
-import de.steamwar.linkage.Linked;
-import org.bukkit.Material;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.type.Wall;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
-import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
-
-@Linked
-public class WallBoundingBox implements BoundingBoxLoader {
-
-    @Override
-    public void load() {
-        v18();
-    }
-
-    private void v18() {
-        for (int nx = 0; nx < 2; nx++) {
-            for (int nz = 0; nz < 2; nz++) {
-                for (int px = 0; px < 2; px++) {
-                    for (int pz = 0; pz < 2; pz++) {
-                        Wall fence = (Wall) Material.END_STONE_BRICK_WALL.createBlockData();
-                        List<String> lore = new ArrayList<>();
-                        List<Cuboid> cuboidList = new ArrayList<>();
-                        cuboidList.add(pixelCuboid(4, 0, 4, 8, 24, 8));
-                        if (nz == 1) {
-                            lore.add("LAUFBAU_CONNECTION_NORTH");
-                            fence.setHeight(BlockFace.NORTH, Wall.Height.LOW);
-                            cuboidList.add(pixelCuboid(5, 0, 0, 6, 24, 4));
-                        }
-                        if (pz == 1) {
-                            lore.add("LAUFBAU_CONNECTION_SOUTH");
-                            fence.setHeight(BlockFace.SOUTH, Wall.Height.LOW);
-                            cuboidList.add(pixelCuboid(5, 0, 12, 6, 24, 4));
-                        }
-                        if (nx == 1) {
-                            lore.add("LAUFBAU_CONNECTION_WEST");
-                            fence.setHeight(BlockFace.WEST, Wall.Height.LOW);
-                            cuboidList.add(pixelCuboid(0, 0, 5, 4, 24, 6));
-                        }
-                        if (px == 1) {
-                            lore.add("LAUFBAU_CONNECTION_EAST");
-                            fence.setHeight(BlockFace.EAST, Wall.Height.LOW);
-                            cuboidList.add(pixelCuboid(12, 0, 5, 4, 24, 6));
-                        }
-                        new BlockBoundingBox(fence, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_WALL", Material.END_STONE_BRICK_WALL, lore.toArray(new String[0])));
-                    }
-                }
-            }
-        }
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/slaves/laufbau/states/CreatingLaufState.java

@@ -145,7 +145,6 @@ public class CreatingLaufState implements LaufbauState {
         }
         try {
             BaseBlock block = BukkitAdapter.adapt(highestBlockBoundingBox.blockData).toBaseBlock();
-            if (highestBlockBoundingBox.blockConsumer != null) highestBlockBoundingBox.blockConsumer.accept(block);
             editSession.setBlock(BukkitAdapter.asBlockVector(location), block);
         } catch (MaxChangedBlocksException e) {
             e.printStackTrace();

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/smartplace/SmartPlaceCommand.java

@@ -35,8 +35,8 @@ public class SmartPlaceCommand extends SWCommand {
 
     @Register(description = {"SMART_PLACE_HELP", "SMART_PLACE_INFO"})
     public void genericToggle(Player p) {
-        boolean smartPlace = Config.getInstance().get(p).getPlainValueOrDefault("smartPlace", false);
-        Config.getInstance().get(p).put("smartPlace", !smartPlace);
+        boolean smartPlace = Config.STORE.get(p).isSmartPlace();
+        Config.STORE.get(p).setSmartPlace(!smartPlace);
         if (!smartPlace) {
             SWUtils.sendToActionbar(p, BauSystem.MESSAGE.parse("SMART_PLACE_ENABLE", p));
             BauSystem.MESSAGE.send("SMART_PLACE_INFO", p);

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/smartplace/SmartPlaceListener.java

@@ -25,6 +25,7 @@ import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.configplayer.Config;
 import de.steamwar.linkage.Linked;
 import net.minecraft.network.protocol.game.ServerboundUseItemOnPacket;
+import net.minecraft.world.InteractionHand;
 import org.bukkit.*;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
@@ -87,7 +88,9 @@ public class SmartPlaceListener implements Listener {
     public SmartPlaceListener() {
         TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, (player, packet) -> {
             if (!Permission.BUILD.hasPermission(player)) return packet;
-            if (!Config.getInstance().get(player).getPlainValueOrDefault("smartPlace", false)) return packet;
+            if (!Config.STORE.get(player).isSmartPlace()) return packet;
+            ItemStack usedItem = packet.getHand() == InteractionHand.MAIN_HAND ? player.getInventory().getItemInMainHand() : player.getInventory().getItemInOffHand();
+            if (usedItem.getType() == Material.DEBUG_STICK) return packet;
             RayTraceResult rayTraceResult = player.rayTraceBlocks(6);
             Block block = rayTraceResult != null ? rayTraceResult.getHitBlock() : null;
             BlockFace blockFace = rayTraceResult != null ? rayTraceResult.getHitBlockFace() : null;
@@ -127,7 +130,7 @@ public class SmartPlaceListener implements Listener {
     @EventHandler
     public void onPlayerInteract(PlayerInteractEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("smartPlace", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isSmartPlace()) return;
         WAS_EXECUTED.add(event.getPlayer());
         if (event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
         if (event.getPlayer().getGameMode() == GameMode.SPECTATOR) return;
@@ -146,7 +149,7 @@ public class SmartPlaceListener implements Listener {
     @EventHandler
     public void onBlockPlace(BlockPlaceEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
-        if (!Config.getInstance().get(event.getPlayer()).getPlainValueOrDefault("smartPlace", false)) return;
+        if (!Config.STORE.get(event.getPlayer()).isSmartPlace()) return;
         if (!SMART_PLACING.contains(event.getPlayer())) {
             if (CONTAINERS.contains(event.getBlockAgainst().getType())) {
                 SoundGroup soundGroup = event.getBlockPlaced().getBlockData().getSoundGroup();

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/team/boundary/BoundaryViewer.java

@@ -19,11 +19,10 @@
 
 package de.steamwar.bausystem.features.team.boundary;
 
-import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.region.Point;
 import de.steamwar.bausystem.region.Region;
 import de.steamwar.linkage.Linked;
-import org.bukkit.Bukkit;
+import de.steamwar.linkage.LinkedTimer;
 import org.bukkit.Particle;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
@@ -38,17 +37,16 @@ public class BoundaryViewer implements Listener {
 
     public static Set<Player> viewers = new HashSet<>();
 
-    {
-        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
-            if (viewers.isEmpty()) {
-                return;
-            }
-            viewers.forEach(player -> {
-                Region region = Region.getRegion(player.getLocation());
-                if (region.getType().isGlobal()) return;
-                showRegion(region, player);
-            });
-        }, 20, 20);
+    @LinkedTimer(delay = 20, period = 20)
+    private void showBoundaries() {
+        if (viewers.isEmpty()) {
+            return;
+        }
+        viewers.forEach(player -> {
+            Region region = Region.getRegion(player.getLocation());
+            if (region.getType().isGlobal()) return;
+            showRegion(region, player);
+        });
     }
 
     private void showRegion(Region region, Player player) {

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

@@ -0,0 +1,161 @@
+/*
+ *   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.techhider;
+
+import de.steamwar.bausystem.features.hullhider.HullHiderCommand;
+import de.steamwar.bausystem.features.world.SpectatorListener;
+import de.steamwar.bausystem.features.xray.XrayCommand;
+import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.techhider.AccessPrivilegeProvider;
+import de.steamwar.techhider.TechHider;
+import net.minecraft.world.level.block.Block;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.block.entity.BlockEntityType;
+import net.minecraft.world.level.block.state.BlockState;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * The single TechHider of the server. It combines the hiding rules of the spectator techhider, /techhider and /xray and the hulls of /hullhider per player.
+ * Entities are never hidden.
+ */
+@Linked
+public class BauTechHider implements AccessPrivilegeProvider {
+
+    private static final HidingRule[] NO_RULES = new HidingRule[0];
+    private static final HiddenHull[] NO_HULLS = new HiddenHull[0];
+
+    // Injected after construction, until then nothing is hidden
+    @LinkedInstance
+    public XrayCommand xrayCommand;
+    @LinkedInstance
+    public TechHiderCommand techHiderCommand;
+    @LinkedInstance
+    public SpectatorListener spectatorListener;
+    @LinkedInstance
+    public HullHiderCommand hullHiderCommand;
+
+    public BauTechHider() {
+        new TechHider(this);
+    }
+
+    @Override
+    public ForPlayer forPlayer(Player p) {
+        if (xrayCommand == null || techHiderCommand == null || spectatorListener == null || hullHiderCommand == null) {
+            return new BauPlayerAccess(p, NO_RULES, NO_HULLS);
+        }
+
+        // Region rules first: where rules overlap, the first one decides the obfuscation block
+        List<HidingRule> rules = new ArrayList<>();
+        xrayCommand.addHidingRules(p, rules);
+        techHiderCommand.addHidingRules(p, rules);
+        hullHiderCommand.addHidingRules(p, rules);
+        spectatorListener.addHidingRules(p, rules);
+
+        List<HiddenHull> hulls = new ArrayList<>();
+        hullHiderCommand.addHiddenHulls(p, hulls);
+        return new BauPlayerAccess(p, rules.toArray(NO_RULES), hulls.toArray(NO_HULLS));
+    }
+
+    @Override
+    public boolean isPlayerPrivilegedToPerformAction(Player p) {
+        return true;
+    }
+
+    /**
+     * Snapshot of the hiding rules of one player, taken once per outgoing packet on the netty thread.
+     */
+    private record BauPlayerAccess(Player player, HidingRule[] rules, HiddenHull[] hulls) implements ForPlayer {
+
+        @Override
+        public Player getPlayer() {
+            return player;
+        }
+
+        @Override
+        public boolean canAccessAllDataWithinChunk(int chunkX, int chunkZ) {
+            for (HidingRule rule : rules) {
+                if (rule.coversChunk(chunkX, chunkZ)) return false;
+            }
+            for (HiddenHull hull : hulls) {
+                if (!hull.hull().getRegion().chunkOutside(chunkX, chunkZ)) return false;
+            }
+            return true;
+        }
+
+        @Override
+        public boolean canAccessPosition(int blockX, int blockY, int blockZ) {
+            for (HiddenHull hull : hulls) {
+                if (hull.hull().isBlockHidden(player, blockX, blockY, blockZ)) return false;
+            }
+            return true;
+        }
+
+        @Override
+        public boolean canAccessBlock(int blockX, int blockY, int blockZ, Block block) {
+            for (HidingRule rule : rules) {
+                if (rule.covers(blockX, blockY, blockZ) && rule.obfuscation().hidesBlock(block)) return false;
+            }
+            return true;
+        }
+
+        @Override
+        public boolean canAccessBlockState(int blockX, int blockY, int blockZ, BlockState blockState) {
+            for (HidingRule rule : rules) {
+                if (rule.covers(blockX, blockY, blockZ) && rule.obfuscation().hidesBlockState(blockState)) return false;
+            }
+            return true;
+        }
+
+        @Override
+        public boolean canAccessEntity(int entityId) {
+            return true;
+        }
+
+        // Entities are not hidden, even if they spawn inside a hidden hull
+        @Override
+        public boolean canAccessEntitySpawn(int entityId, int blockX, int blockY, int blockZ) {
+            return true;
+        }
+
+        @Override
+        public boolean canAccessBlockEntity(int blockX, int blockY, int blockZ, BlockEntityType<?> type) {
+            for (HidingRule rule : rules) {
+                if (rule.covers(blockX, blockY, blockZ) && rule.obfuscation().hidesBlockEntity(type)) return false;
+            }
+            return true;
+        }
+
+        @Override
+        public BlockState getObfuscation(int blockX, int blockY, int blockZ) {
+            for (HidingRule rule : rules) {
+                if (rule.covers(blockX, blockY, blockZ)) return rule.obfuscation().getObfuscationState();
+            }
+            for (HiddenHull hull : hulls) {
+                if (hull.hull().getRegion().contains(blockX, blockY, blockZ)) return hull.obfuscation();
+            }
+            // Only asked for positions a rule or hull hides
+            return Blocks.END_STONE.defaultBlockState();
+        }
+    }
+}

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

@@ -0,0 +1,29 @@
+/*
+ *   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.techhider;
+
+import de.steamwar.hullhider.Hull;
+import net.minecraft.world.level.block.state.BlockState;
+
+/**
+ * A hull a player may not view, and the block sent instead of its hidden blocks.
+ */
+public record HiddenHull(Hull hull, BlockState obfuscation) {
+}

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

@@ -0,0 +1,52 @@
+/*
+ *   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.techhider;
+
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.hullhider.HullRegion;
+import de.steamwar.techhider.ObfuscationConfig;
+
+/**
+ * Hides the blocks of an obfuscation config within an area, or everywhere if the area is null.
+ */
+public record HidingRule(HullRegion area, ObfuscationConfig obfuscation) {
+
+    public static HidingRule everywhere(ObfuscationConfig obfuscation) {
+        return new HidingRule(null, obfuscation);
+    }
+
+    /**
+     * Covers the area including its extension.
+     */
+    public static HidingRule of(Region.Area area, ObfuscationConfig obfuscation) {
+        Point min = area.getMinPoint(true);
+        Point max = area.getMaxPoint(true);
+        return new HidingRule(HullRegion.fromInclusive(min.getX(), min.getY(), min.getZ(), max.getX(), max.getY(), max.getZ()), obfuscation);
+    }
+
+    public boolean covers(int x, int y, int z) {
+        return area == null || area.contains(x, y, z);
+    }
+
+    public boolean coversChunk(int chunkX, int chunkZ) {
+        return area == null || !area.chunkOutside(chunkX, chunkZ);
+    }
+}

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

@@ -21,17 +21,17 @@ package de.steamwar.bausystem.features.techhider;
 
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
+import de.steamwar.bausystem.features.hullhider.HullHiderCommand;
 import de.steamwar.bausystem.features.world.SpectatorListener;
 import de.steamwar.bausystem.features.xray.XrayCommand;
 import de.steamwar.bausystem.region.Region;
-import de.steamwar.bausystem.utils.ScoreboardElement;
 import de.steamwar.command.PreviousArguments;
 import de.steamwar.command.SWCommand;
 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 de.steamwar.techhider.ObfuscationConfig;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.Bukkit;
 import org.bukkit.command.CommandSender;
@@ -41,21 +41,26 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.stream.Collectors;
 
 @Linked
-public class TechHiderCommand extends SWCommand implements Listener, ScoreboardElement {
+public class TechHiderCommand extends SWCommand implements Listener {
 
     public TechHiderCommand() {
         super("techhider", "hider", "obfuscate", "hide", "hide-tech");
     }
 
-    private Map<Region, Optional<TechHider>> techHiders = new HashMap<>();
-    private Map<Region, Set<Player>> hidden = new HashMap<>();
+    // Read on netty threads by the BauTechHider
+    private Map<Region, Optional<HidingRule>> hidingRules = new ConcurrentHashMap<>();
+    private Map<Region, Set<Player>> hidden = new ConcurrentHashMap<>();
 
     @LinkedInstance
     public XrayCommand xrayCommand;
 
+    @LinkedInstance
+    public HullHiderCommand hullHiderCommand;
+
     @Register(description = "TECHHIDER_HELP")
     public void toggleHider(@Validator Player player) {
         Region region = Region.getRegion(player.getLocation());
@@ -64,26 +69,20 @@ public class TechHiderCommand extends SWCommand implements Listener, ScoreboardE
             return;
         }
 
-        Optional<TechHider> techHider = techHiders.computeIfAbsent(region, rg -> {
+        Optional<HidingRule> hidingRule = hidingRules.computeIfAbsent(region, rg -> {
             if (!region.getGameModeConfig().Techhider.Active) {
                 return Optional.empty();
             }
 
-            hidden.put(rg, new HashSet<>());
-
-            TechHider current = new TechHider((p, cX, cY) -> {
-                if (rg.getBuildArea().isChunkOutside(cX, cY)) return true;
-                return !hidden.get(rg).contains(p);
-            }, region.getGameModeConfig().Techhider.ObfuscateWith, region.getGameModeConfig().Techhider.HiddenBlocks, region.getGameModeConfig().Techhider.HiddenBlockEntities);
-            current.enable();
-
-            return Optional.of(current);
+            hidden.put(rg, ConcurrentHashMap.newKeySet());
+            return Optional.of(HidingRule.of(rg.getBuildArea(), ObfuscationConfig.of(rg.getGameModeConfig().Techhider)));
         });
-        if (!techHider.isPresent()) {
+        if (!hidingRule.isPresent()) {
             return;
         }
 
         xrayCommand.disable(region, player);
+        hullHiderCommand.disable(region, player);
         if (hidden.get(region).contains(player)) {
             hidden.get(region).remove(player);
             BauSystem.MESSAGE.sendPrefixless("TECHHIDER_OFF", player, ChatMessageType.ACTION_BAR);
@@ -128,6 +127,14 @@ public class TechHiderCommand extends SWCommand implements Listener, ScoreboardE
         hidden.values().forEach(set -> set.remove(event.getPlayer()));
     }
 
+    public void addHidingRules(Player player, List<HidingRule> rules) {
+        hidden.forEach((region, players) -> {
+            if (players.contains(player)) {
+                hidingRules.getOrDefault(region, Optional.empty()).ifPresent(rules::add);
+            }
+        });
+    }
+
     public void disable(Region region, Player player) {
         hidden.computeIfPresent(region, (rg, set) -> {
             set.remove(player);
@@ -135,19 +142,7 @@ public class TechHiderCommand extends SWCommand implements Listener, ScoreboardE
         });
     }
 
-    @Override
-    public ScoreboardGroup getGroup() {
-        return ScoreboardGroup.OTHER;
-    }
-
-    @Override
-    public int order() {
-        return 0;
-    }
-
-    @Override
-    public String get(Region region, Player p) {
-        if (!hidden.getOrDefault(region, Collections.emptySet()).contains(p)) return null;
-        return "§e" + BauSystem.MESSAGE.parse("SCOREBOARD_TECHHIDER", p);
+    public boolean isActive(Region region, Player player) {
+        return hidden.getOrDefault(region, Collections.emptySet()).contains(player);
     }
 }

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

@@ -0,0 +1,70 @@
+/*
+ *   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.techhider;
+
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.bausystem.features.hullhider.HullHiderCommand;
+import de.steamwar.bausystem.features.xray.XrayCommand;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.utils.ScoreboardElement;
+import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedInstance;
+import org.bukkit.entity.Player;
+
+/**
+ * Shows which of /techhider, /xray and /hullhider is active, at most one of them can be per region.
+ */
+@Linked
+public class ViewScoreboardElement implements ScoreboardElement {
+
+    @LinkedInstance
+    public TechHiderCommand techHiderCommand;
+
+    @LinkedInstance
+    public XrayCommand xrayCommand;
+
+    @LinkedInstance
+    public HullHiderCommand hullHiderCommand;
+
+    @Override
+    public ScoreboardGroup getGroup() {
+        return ScoreboardGroup.OTHER;
+    }
+
+    @Override
+    public int order() {
+        return 0;
+    }
+
+    @Override
+    public String get(Region region, Player p) {
+        String view;
+        if (techHiderCommand.isActive(region, p)) {
+            view = "TechHider";
+        } else if (xrayCommand.isActive(region, p)) {
+            view = "XRay";
+        } else if (hullHiderCommand.isActive(region, p)) {
+            view = "HullHider";
+        } else {
+            return null;
+        }
+        return "§e" + BauSystem.MESSAGE.parse("SCOREBOARD_VIEW", p, view);
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/testblock/blockcounter/BlockCounter.java

@@ -35,18 +35,15 @@ public class BlockCounter {
     public final Map<Region, BlockCount> blockCountMap = new HashMap<>();
 
     public boolean isActive(final Player p) {
-        if (!Config.getInstance().get(p).containsKey("blockCounter")) {
-            return false;
-        }
-        return Config.getInstance().get(p).getPlainValue("blockCounter");
+        return Config.STORE.get(p).isBlockCounter();
     }
 
     public void enable(final Player p) {
-        Config.getInstance().get(p).put("blockCounter", true);
+        Config.STORE.get(p).setBlockCounter(true);
     }
 
     public void disable(final Player p) {
-        Config.getInstance().get(p).put("blockCounter", false);
+        Config.STORE.get(p).setBlockCounter(false);
     }
 
     public String getMessage(Player player, int count, int tntCount, long tick, long lastTick) {

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

@@ -50,6 +50,9 @@ import java.util.Arrays;
 @Linked
 public class TPSSystem implements Listener {
 
+    @Linked
+    private final TickManager tickManager = TickManager.impl;
+
     public TPSSystem() {
         if (TickManager.impl.canFreeze()) {
             new TPSFreezeCommand();
@@ -68,7 +71,6 @@ public class TPSSystem implements Listener {
         new TickDefaultCommand();
         new TPSBaseCommand();
         new TickBaseCommand();
-        Bukkit.getPluginManager().registerEvents(TickManager.impl, BauSystem.getInstance());
     }
 
     @EventHandler

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

@@ -36,13 +36,10 @@ import org.bukkit.entity.Player;
 import org.bukkit.util.Transformation;
 import org.joml.Quaternionf;
 import org.joml.Vector3f;
-import yapion.hierarchy.types.YAPIONValue;
 
 import java.util.List;
 import java.util.stream.Collectors;
 
-import static de.steamwar.bausystem.features.util.TNTClickListener.TNT_CLICK_DETAILS;
-
 /**
  * Wrapper for the rendering of a record bundle
  */
@@ -102,7 +99,7 @@ public class TraceEntity extends RBlockDisplay {
      * @param player the player the message should be printed for
      */
     public void printIntoChat(Player player) {
-        if (!Config.getInstance().get(player).getOrSetDefault(TNT_CLICK_DETAILS, new YAPIONValue<>(true)).asBoolean().orElse(true)) {
+        if (!Config.STORE.get(player).isTntClickDetails()) {
             return;
         }
         TNTPoint representative = records.get(0);

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

@@ -30,7 +30,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
 import org.bukkit.potion.PotionEffect;
 import org.bukkit.potion.PotionEffectType;
-import yapion.hierarchy.types.YAPIONObject;
 
 @Linked
 public class NightVisionCommand extends SWCommand implements Listener {
@@ -41,15 +40,15 @@ public class NightVisionCommand extends SWCommand implements Listener {
 
     @Register(description = "NIGHT_VISION_HELP")
     public void genericCommand(Player p) {
-        YAPIONObject yapionObject = Config.getInstance().get(p);
-        boolean value = !yapionObject.getBooleanOrDefault("nightvision", false);
-        yapionObject.put("nightvision", value);
+        Config config = Config.STORE.get(p);
+        boolean value = !config.isNightVision();
+        config.setNightVision(value);
         setNightVision(p, value);
     }
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
-        setNightVision(event.getPlayer(), Config.getInstance().get(event.getPlayer()).getBooleanOrDefault("nightvision", false));
+        setNightVision(event.getPlayer(), Config.STORE.get(event.getPlayer()).isNightVision());
     }
 
     private void setNightVision(Player p, boolean value) {

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

@@ -22,123 +22,71 @@ package de.steamwar.bausystem.features.util;
 import com.comphenix.tinyprotocol.TinyProtocol;
 import com.mojang.authlib.GameProfile;
 import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.features.tpslimit.TPSUtils;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.command.SWCommand;
 import de.steamwar.core.ProtocolWrapper;
 import de.steamwar.core.SWPlayer;
 import de.steamwar.linkage.Linked;
-import net.minecraft.network.protocol.game.*;
-import net.minecraft.world.entity.player.Abilities;
-import net.minecraft.world.level.GameType;
-import org.bukkit.Bukkit;
+import io.papermc.paper.event.player.PlayerFailMoveEvent;
+import net.minecraft.network.protocol.game.ClientboundGameEventPacket;
 import org.bukkit.GameMode;
-import org.bukkit.craftbukkit.entity.CraftPlayer;
-import org.bukkit.craftbukkit.inventory.CraftItemStack;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.block.BlockCanBuildEvent;
 import org.bukkit.event.player.PlayerGameModeChangeEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
 import org.bukkit.event.player.PlayerToggleFlightEvent;
 
-import java.util.function.BiFunction;
-
 @Linked
 public class NoClipCommand extends SWCommand implements Listener {
 
     public static class NoClipData implements SWPlayer.Component {
-        private long lastTick = -1;
-
         @Override
-        public void onUnmount(SWPlayer player) {
-            player.getPlayer().setGameMode(GameMode.CREATIVE);
+        public void onUnmount(SWPlayer swPlayer) {
+            Player player = swPlayer.getPlayer();
+            showClientGameMode(player, GameMode.CREATIVE, GameMode.CREATIVE);
         }
     }
 
     public NoClipCommand() {
         super("noclip", "nc");
-
-        BiFunction<Player, ServerboundMovePlayerPacket, Object> first = (player, o) -> {
-            NoClipData noClipData = SWPlayer.of(player).getComponent(NoClipData.class).orElse(null);
-            if (noClipData == null) return o;
-            if (noClipData.lastTick == TPSUtils.currentTick.get()) return o;
-            setInternalGameMode(player, GameMode.SPECTATOR);
-            noClipData.lastTick = TPSUtils.currentTick.get();
-            return o;
-        };
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, first);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, first);
-
-        BiFunction<Player, Object, Object> second = (player, o) -> {
-            NoClipData noClipData = SWPlayer.of(player).getComponent(NoClipData.class).orElse(null);
-            if (noClipData == null) return o;
-            setInternalGameMode(player, GameMode.CREATIVE);
-            noClipData.lastTick = TPSUtils.currentTick.get();
-            return o;
-        };
-        TinyProtocol.instance.addFilter(ServerboundUseItemOnPacket.class, second);
-        TinyProtocol.instance.addFilter(ServerboundPlayerActionPacket.class, second);
-        TinyProtocol.instance.addFilter(ServerboundContainerClickPacket.class, second);
-
-        BiFunction<Player, ServerboundSetCreativeModeSlotPacket, Object> third = (player, o) -> {
-            if (SWPlayer.of(player).hasComponent(NoClipData.class)) {
-                int index = o.slotNum();
-                if (index >= 36 && index <= 44) {
-                    index -= 36;
-                } else if (index > 44) {
-                    index -= 5;
-                } else if (index <= 8) {
-                    index = index - 8 + 36;
-                }
-                player.getInventory().setItem(index, CraftItemStack.asBukkitCopy(o.itemStack()));
-                if (index < 9) player.getInventory().setHeldItemSlot(index);
-                player.updateInventory();
-            }
-            return o;
-        };
-        TinyProtocol.instance.addFilter(ServerboundSetCreativeModeSlotPacket.class, third);
     }
 
-    private void setInternalGameMode(Player player, GameMode gameMode) {
-        ((CraftPlayer) player).getHandle().gameMode.gameModeForPlayer = GameType.byId(gameMode.getValue());
-    }
-
-    @Register(help = true)
+    @Register
     public void genericCommand(@Validator Player player) {
         SWPlayer swPlayer = SWPlayer.of(player);
         if (swPlayer.hasComponent(NoClipData.class)) {
             swPlayer.removeComponent(NoClipData.class);
         } else {
-            player.setGameMode(GameMode.SPECTATOR);
-            Abilities abilities = (((CraftPlayer) player).getHandle()).getAbilities();
-            abilities.mayBuild = true;
-            abilities.mayfly = true;
-            abilities.instabuild = true;
-
+            player.setGameMode(GameMode.CREATIVE);
+            player.setAllowFlight(true);
+            player.setFlying(true);
             swPlayer.setComponent(new NoClipData());
             BauSystem.MESSAGE.send("OTHER_NOCLIP_SLOT_INFO", player);
-            TinyProtocol.instance.sendPacket(player, new ClientboundGameEventPacket(ClientboundGameEventPacket.CHANGE_GAME_MODE, 1F));
-            pseudoGameMode(player, GameMode.SPECTATOR);
+            showClientGameMode(player, GameMode.CREATIVE, GameMode.SPECTATOR);
         }
     }
 
     @EventHandler
-    public void onBauMemberUpdate(BauMemberUpdateEvent event) {
-        event.getNewSpectator().forEach(player -> {
-            SWPlayer.of(player).removeComponent(NoClipData.class);
-        });
+    public void onPlayerFailMove(PlayerFailMoveEvent event) {
+        if (event.getFailReason() != PlayerFailMoveEvent.FailReason.CLIPPED_INTO_BLOCK) return;
+        if (!SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) return;
+        event.setAllowed(true);
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
+    public void onBauMemberUpdate(BauMemberUpdateEvent event) {
+        event.getNewSpectator().forEach(player -> SWPlayer.of(player).removeComponent(NoClipData.class));
+    }
+
+    @EventHandler
     public void onPlayerGameModeChange(PlayerGameModeChangeEvent event) {
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
             event.setCancelled(true);
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
     public void onBlock(BlockCanBuildEvent event) {
         if (event.getPlayer() == null) return;
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
@@ -146,7 +94,7 @@ public class NoClipCommand extends SWCommand implements Listener {
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
+    @EventHandler
     public void onPlayerToggleFlight(PlayerToggleFlightEvent event) {
         if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
             event.setCancelled(true);
@@ -154,20 +102,13 @@ public class NoClipCommand extends SWCommand implements Listener {
         }
     }
 
-    @EventHandler(ignoreCancelled = true)
-    public void onPlayerTeleport(PlayerTeleportEvent event) {
-        if (event.getCause() != PlayerTeleportEvent.TeleportCause.SPECTATE) {
-            return;
-        }
-        if (SWPlayer.of(event.getPlayer()).hasComponent(NoClipData.class)) {
-            event.setCancelled(true);
-            Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-                event.getPlayer().setSpectatorTarget(null);
-            }, 1L);
-        }
+    /**
+     * @param player player
+     * @param localMode GameMode for breaking and placing
+     * @param listedMode GameMode for noPhysics
+     */
+    private static void showClientGameMode(Player player, GameMode localMode, GameMode listedMode) {
+        TinyProtocol.instance.sendPacket(player, new ClientboundGameEventPacket(ClientboundGameEventPacket.CHANGE_GAME_MODE, localMode.getValue()));
+        TinyProtocol.instance.sendPacket(player, ProtocolWrapper.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.GAMEMODE, new GameProfile(player.getUniqueId(), player.getName()), listedMode));
     }
-
-    private static void pseudoGameMode(Player player, GameMode gameMode) {
-        TinyProtocol.instance.sendPacket(player, ProtocolWrapper.playerInfoPacketConstructor(ProtocolWrapper.PlayerInfoAction.GAMEMODE, new GameProfile(player.getUniqueId(), player.getName()), gameMode));
-    }
-}
+}

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

@@ -23,15 +23,17 @@ import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.entity.*;
 import de.steamwar.linkage.Linked;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Direction;
+import net.minecraft.world.level.block.piston.PistonStructureResolver;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 import org.bukkit.block.Block;
 import org.bukkit.block.BlockFace;
-import org.bukkit.block.PistonMoveReaction;
-import org.bukkit.block.TileState;
 import org.bukkit.block.data.BlockData;
 import org.bukkit.block.data.type.Piston;
+import org.bukkit.craftbukkit.CraftWorld;
 import org.bukkit.entity.Display;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.TextDisplay;
@@ -92,41 +94,48 @@ public class PistonCalculator implements Listener {
     @EventHandler
     public void onBlockPistonExtend(BlockPistonExtendEvent event) {
         if (pistOrders.isEmpty()) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            movePistOrders(event.getDirection(), event.getBlocks());
-            pistOrders.values().forEach(PistOrder::calculate);
-        }, 3);
+        removeMovedPistOrders(event.getBlocks());
+        scheduleRecalculate();
     }
 
     @EventHandler
     public void onBlockPistonRetract(BlockPistonRetractEvent event) {
         if (pistOrders.isEmpty()) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            movePistOrders(event.getDirection(), event.getBlocks());
-            pistOrders.values().forEach(PistOrder::calculate);
-        }, 3);
+        removeMovedPistOrders(event.getBlocks());
+        scheduleRecalculate();
     }
 
-    private void movePistOrders(BlockFace direction, List<Block> blocks) {
-        Set<PistOrder> orders = new HashSet<>();
+    private void removeMovedPistOrders(List<Block> blocks) {
         blocks.forEach(block -> {
-            PistOrder pistOrder = pistOrders.get(block.getLocation());
-            if (pistOrder == null) return;
-            pistOrders.remove(block.getLocation());
-            pistOrder.piston = pistOrder.piston.getRelative(direction);
-            orders.add(pistOrder);
-        });
-        orders.forEach(pistOrder -> {
-            pistOrders.put(pistOrder.piston.getLocation(), pistOrder);
+            PistOrder pistOrder = pistOrders.remove(block.getLocation());
+            if (pistOrder != null) pistOrder.server.close();
         });
     }
 
+    private static final long RECALCULATE_INTERVAL_MS = 200;
+    private boolean recalculationScheduled = false;
+    private long lastRecalculation = 0;
+
+    private void scheduleRecalculate() {
+        if (recalculationScheduled) return;
+        recalculationScheduled = true;
+        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), this::recalculateIfDue, 1);
+    }
+
+    private void recalculateIfDue() {
+        if (System.currentTimeMillis() - lastRecalculation < RECALCULATE_INTERVAL_MS) {
+            Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), this::recalculateIfDue, 1);
+            return;
+        }
+        recalculationScheduled = false;
+        lastRecalculation = System.currentTimeMillis();
+        pistOrders.values().forEach(PistOrder::calculate);
+    }
+
     @EventHandler
     public void onBlockPlace(BlockPlaceEvent event) {
         if (pistOrders.isEmpty()) return;
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            pistOrders.values().forEach(PistOrder::calculate);
-        }, 1);
+        scheduleRecalculate();
     }
 
     @EventHandler
@@ -136,9 +145,7 @@ public class PistonCalculator implements Listener {
             PistOrder pistOrder = pistOrders.remove(event.getBlock().getLocation());
             pistOrder.server.close();
         }
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
-            pistOrders.values().forEach(PistOrder::calculate);
-        }, 1);
+        scheduleRecalculate();
     }
 
     @EventHandler
@@ -164,13 +171,13 @@ public class PistonCalculator implements Listener {
     private final Map<Location, PistOrder> pistOrders = new HashMap<>();
 
     private final class PistOrder {
-        private Block piston;
+        private final Block piston;
         private REntityServer server = new REntityServer();
 
         private boolean pulling = false;
         private List<Location> movedBlocks = new ArrayList<>();
         private List<Location> brokenBlocks = new ArrayList<>();
-        private Set<Location> immovableBlocks = new HashSet<>();
+        private boolean blocked = false;
 
         public PistOrder(Block piston) {
             this.piston = piston;
@@ -179,7 +186,7 @@ public class PistonCalculator implements Listener {
         public void calculate() {
             movedBlocks.clear();
             brokenBlocks.clear();
-            immovableBlocks.clear();
+            blocked = false;
 
             if (piston.isEmpty()) {
                 Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), () -> {
@@ -199,7 +206,7 @@ public class PistonCalculator implements Listener {
 
             pulling = piston.getType() == Material.STICKY_PISTON && (piston.getRelative(pistonData.getFacing()).getType() == Material.AIR || pistonData.isExtended());
 
-            calculate(piston, pistonData.getFacing(), (pulling ? pistonData.getFacing().getOppositeFace() : pistonData.getFacing()));
+            resolve(pistonData.getFacing());
 
             Collections.reverse(movedBlocks);
             Collections.reverse(brokenBlocks);
@@ -207,86 +214,23 @@ public class PistonCalculator implements Listener {
             visualize();
         }
 
-        private void calculate(Block origin, BlockFace facing, BlockFace direction) {
-            Block calcOrigin = origin;
-            if (facing != direction) calcOrigin = origin.getRelative(facing, 3);
-
-            List<Block> toCalc = new LinkedList<>();
-            calcDirection(origin, null, calcOrigin, facing != direction ? origin.getRelative(facing) : null, facing, direction, toCalc);
-
-            while (!toCalc.isEmpty()) {
-                Block current = toCalc.remove(0);
-                if (!movedBlocks.contains(current.getLocation())) {
-                    movedBlocks.add(current.getLocation());
-                }
-
-                Material type = current.getType();
-                if (type != Material.SLIME_BLOCK && type != Material.HONEY_BLOCK) continue;
-                Material oppositeType = type == Material.SLIME_BLOCK ? Material.HONEY_BLOCK : Material.SLIME_BLOCK;
-
-                for (BlockFace face : FACES) {
-                    Block block = current.getRelative(face);
-                    if (block.getType().isAir()) continue;
-                    if (isImmovable(block) || block.getPistonMoveReaction() == PistonMoveReaction.BREAK) continue;
-                    if (face != direction || face == direction.getOppositeFace()) {
-                        switch (block.getType()) {
-                            case BLACK_GLAZED_TERRACOTTA:
-                            case GRAY_GLAZED_TERRACOTTA:
-                            case BLUE_GLAZED_TERRACOTTA:
-                            case BROWN_GLAZED_TERRACOTTA:
-                            case CYAN_GLAZED_TERRACOTTA:
-                            case GREEN_GLAZED_TERRACOTTA:
-                            case LIGHT_BLUE_GLAZED_TERRACOTTA:
-                            case LIGHT_GRAY_GLAZED_TERRACOTTA:
-                            case LIME_GLAZED_TERRACOTTA:
-                            case MAGENTA_GLAZED_TERRACOTTA:
-                            case ORANGE_GLAZED_TERRACOTTA:
-                            case PINK_GLAZED_TERRACOTTA:
-                            case PURPLE_GLAZED_TERRACOTTA:
-                            case RED_GLAZED_TERRACOTTA:
-                            case WHITE_GLAZED_TERRACOTTA:
-                            case YELLOW_GLAZED_TERRACOTTA:
-                                continue;
-                            default:
-                                break;
-                        }
-                    }
-                    if (block.getType() != oppositeType) {
-                        if (!movedBlocks.contains(block.getLocation())) toCalc.add(block);
-                        calcDirection(null, origin, block, null, facing, direction, toCalc);
-                    }
-                }
+        private void resolve(BlockFace facing) {
+            PistonStructureResolver resolver = new PistonStructureResolver(
+                    ((CraftWorld) piston.getWorld()).getHandle(),
+                    new BlockPos(piston.getX(), piston.getY(), piston.getZ()),
+                    Direction.valueOf(facing.name()),
+                    !pulling
+            );
+            if (!resolver.resolve()) {
+                blocked = true;
+                return;
             }
-
-            movedBlocks.remove(origin.getLocation());
-            if (facing != direction) movedBlocks.remove(origin.getRelative(facing, 1).getLocation());
-            if (pulling) immovableBlocks.remove(origin.getRelative(facing).getLocation());
+            resolver.getToPush().forEach(pos -> movedBlocks.add(toLocation(pos)));
+            resolver.getToDestroy().forEach(pos -> brokenBlocks.add(toLocation(pos)));
         }
 
-        private void calcDirection(Block origin, Block blockOrigin, Block calcOrigin, Block ignore, BlockFace facing, BlockFace direction, List<Block> toCalc) {
-            for (int i = 1; i < 24; i++) {
-                Block block = calcOrigin.getRelative(direction, i);
-                if (block.equals(ignore)) return;
-                if (block.getPistonMoveReaction() == PistonMoveReaction.BREAK) {
-                    if (!brokenBlocks.contains(block.getLocation())) {
-                        brokenBlocks.add(block.getLocation());
-                    }
-                    return;
-                }
-                if (isImmovable(block)) {
-                    immovableBlocks.add(block.getLocation());
-                    return;
-                }
-                if (block.getType().isAir()) return;
-                if (facing == direction && block.equals(blockOrigin)) {
-                    immovableBlocks.add(block.getLocation());
-                    return;
-                }
-                if (facing != direction && (block.equals(origin) || block.getRelative(facing.getOppositeFace()).equals(origin))) {
-                    return;
-                }
-                if (!movedBlocks.contains(block.getLocation())) toCalc.add(block);
-            }
+        private Location toLocation(BlockPos pos) {
+            return new Location(piston.getWorld(), pos.getX(), pos.getY(), pos.getZ());
         }
 
         private void visualize() {
@@ -321,21 +265,11 @@ public class PistonCalculator implements Listener {
                 textDisplay.setBrightness(new Display.Brightness(15, 15));
             }
 
-            for (Location location : immovableBlocks) {
-                CWireframe wireframe = new CWireframe(server);
-                wireframe.setPos1(location);
-                wireframe.setPos2(location);
-                wireframe.setWidth(1 / 32f);
-                wireframe.setBlock(Material.RED_CONCRETE.createBlockData());
-            }
-
             CWireframe wireframe = new CWireframe(server);
             wireframe.setPos1(piston.getLocation());
             wireframe.setPos2(piston.getLocation());
-            if (!immovableBlocks.isEmpty()) {
+            if (blocked) {
                 wireframe.setBlock(Material.RED_CONCRETE.createBlockData());
-            } else if (movedBlocks.size() > 12) {
-                wireframe.setBlock(Material.YELLOW_CONCRETE.createBlockData());
             } else {
                 wireframe.setBlock(Material.LIME_CONCRETE.createBlockData());
             }
@@ -348,7 +282,11 @@ public class PistonCalculator implements Listener {
             } else {
                 text.append("§ePush\n");
             }
-            text.append("§f").append(movedBlocks.size()).append(" §eBlocks");
+            if (blocked) {
+                text.append("§cBlocked");
+            } else {
+                text.append("§f").append(movedBlocks.size()).append(" §eBlocks");
+            }
             textDisplay.setText(text.toString());
             textDisplay.setBillboard(Display.Billboard.CENTER);
             textDisplay.setAlignment(TextDisplay.TextAlignment.CENTER);
@@ -358,26 +296,4 @@ public class PistonCalculator implements Listener {
             textDisplay.setBrightness(new Display.Brightness(15, 15));
         }
     }
-
-    private boolean isImmovable(Block block) {
-        if (block.isEmpty() || block.isLiquid()) {
-            return false;
-        }
-        BlockData blockData = block.getBlockData();
-        if (blockData instanceof Piston) {
-            return ((Piston) blockData).isExtended();
-        }
-        if (block.getState() instanceof TileState) {
-            return true;
-        }
-        PistonMoveReaction reaction = block.getPistonMoveReaction();
-        if (reaction == PistonMoveReaction.IGNORE) return true;
-        if (reaction == PistonMoveReaction.BLOCK) return true;
-        switch (block.getType()) {
-            case OBSIDIAN:
-                return true;
-            default:
-                return false;
-        }
-    }
 }

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

@@ -32,26 +32,22 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerInteractEntityEvent;
 import org.bukkit.inventory.EquipmentSlot;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.hierarchy.types.YAPIONValue;
 
 @Linked
 public class TNTClickListener extends SWCommand implements Listener {
 
-    public static final String TNT_CLICK_DETAILS = "tnt_click_details";
-
     public TNTClickListener() {
         super("tntdetails");
     }
 
     @Register(description = "TNT_DETAILS_COMMAND")
     public void toggle(Player player) {
-        YAPIONObject yapionObject = Config.getInstance().get(player);
-        if (yapionObject.getOrSetDefault(TNT_CLICK_DETAILS, new YAPIONValue<>(true)).asBoolean().orElse(true)) {
-            yapionObject.put(TNT_CLICK_DETAILS, false);
+        Config config = Config.STORE.get(player);
+        if (config.isTntClickDetails()) {
+            config.setTntClickDetails(false);
             BauSystem.MESSAGE.send("TNT_DETAILS_OFF", player);
         } else {
-            yapionObject.put(TNT_CLICK_DETAILS, true);
+            config.setTntClickDetails(true);
             BauSystem.MESSAGE.send("TNT_DETAILS_ON", player);
         }
     }
@@ -60,7 +56,7 @@ public class TNTClickListener extends SWCommand implements Listener {
     public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
         if (!Permission.BUILD.hasPermission(event.getPlayer())) return;
         if (event.getHand() != EquipmentSlot.HAND) return;
-        if (!Config.getInstance().get(event.getPlayer()).getOrSetDefault(TNT_CLICK_DETAILS, new YAPIONValue<>(true)).asBoolean().orElse(true)) {
+        if (!Config.STORE.get(event.getPlayer()).isTntClickDetails()) {
             return;
         }
 

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/warp/Warp.java

@@ -25,7 +25,6 @@ import lombok.Getter;
 import org.bukkit.*;
 import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerTeleportEvent;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.*;
 
@@ -56,27 +55,22 @@ public class Warp {
         warpMap.put(name, this);
     }
 
-    public Warp(String name, YAPIONObject object) {
+    public Warp(String name, WorldData.WarpEntry warp) {
         this.name = name;
-        double x = object.getPlainValue("x");
-        double y = object.getPlainValue("y");
-        double z = object.getPlainValue("z");
-        float yaw = object.getPlainValue("yaw");
-        float pitch = object.getPlainValue("pitch");
-        location = new Location(Bukkit.getWorlds().get(0), x, y, z, yaw, pitch);
-        mat = Material.getMaterial(object.getPlainValue("material"));
+        location = new Location(Bukkit.getWorlds().get(0), warp.getX(), warp.getY(), warp.getZ(), warp.getYaw(), warp.getPitch());
+        mat = Material.getMaterial(warp.getMaterial());
         warpMap.put(name, this);
     }
 
-    public YAPIONObject output() {
-        YAPIONObject yapionObject = new YAPIONObject();
-        yapionObject.add("x", location.getX());
-        yapionObject.add("y", location.getY());
-        yapionObject.add("z", location.getZ());
-        yapionObject.add("yaw", location.getYaw());
-        yapionObject.add("pitch", location.getPitch());
-        yapionObject.add("material", mat.toString());
-        return yapionObject;
+    public WorldData.WarpEntry output() {
+        WorldData.WarpEntry warp = new WorldData.WarpEntry();
+        warp.setX(location.getX());
+        warp.setY(location.getY());
+        warp.setZ(location.getZ());
+        warp.setYaw(location.getYaw());
+        warp.setPitch(location.getPitch());
+        warp.setMaterial(mat.toString());
+        return warp;
     }
 
     public static Set<String> getWarpNames() {
@@ -101,7 +95,7 @@ public class Warp {
 
     public void delete() {
         warpMap.remove(name);
-        WorldData.getWarpData().remove(name);
+        WorldData.STORE.get().getWarps().remove(name);
     }
 
     public void teleport(Player player) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/warp/WarpCommand.java

@@ -34,9 +34,9 @@ import net.md_5.bungee.api.chat.ComponentBuilder;
 import net.md_5.bungee.api.chat.HoverEvent;
 import net.md_5.bungee.api.chat.TextComponent;
 import org.bukkit.entity.Player;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.ArrayList;
+import java.util.Map;
 
 @Linked
 public class WarpCommand extends SWCommand implements Disable, Enable {
@@ -135,17 +135,15 @@ public class WarpCommand extends SWCommand implements Disable, Enable {
 
     @Override
     public void enable() {
-        WorldData.getWarpData().forEach((name, yapionAnyType) -> {
-            new Warp(name, (YAPIONObject) yapionAnyType);
-        });
+        WorldData.STORE.get().getWarps().forEach(Warp::new);
         Warp.enable();
     }
 
     @Override
     public void disable() {
-        YAPIONObject yapionObject = WorldData.getWarpData();
+        Map<String, WorldData.WarpEntry> warps = WorldData.STORE.get().getWarps();
         for (Warp warp : Warp.getWarps()) {
-            yapionObject.add(warp.getName(), warp.output());
+            warps.put(warp.getName(), warp.output());
         }
     }
 }

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

@@ -23,6 +23,7 @@ import de.steamwar.bausystem.BauSystem;
 import de.steamwar.core.CRIUWakeupEvent;
 import de.steamwar.core.CheckpointUtils;
 import de.steamwar.linkage.Linked;
+import de.steamwar.linkage.LinkedTimer;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.entity.Player;
@@ -38,17 +39,16 @@ public class AFKStopperListener implements Listener {
 
     private long lastMovementTime = System.currentTimeMillis();
 
-    public AFKStopperListener() {
-        Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), () -> {
-            long currentTime = System.currentTimeMillis();
-            if (currentTime - lastMovementTime > 10 * 60000) { // 10 Minutes
-                for (Player p : Bukkit.getOnlinePlayers()) {
-                    p.kickPlayer(BauSystem.MESSAGE.parse("AFK_KICK_MESSAGE", p));
-                }
-            } else if (currentTime - lastMovementTime > 9 * 60000) {
-                BauSystem.MESSAGE.broadcast("AFK_WARNING_MESSAGE");
+    @LinkedTimer(delay = 1, period = 1, unit = LinkedTimer.Unit.MINUTES)
+    private void checkAfk() {
+        long currentTime = System.currentTimeMillis();
+        if (currentTime - lastMovementTime > 10 * 60000) { // 10 Minutes
+            for (Player p : Bukkit.getOnlinePlayers()) {
+                p.kickPlayer(BauSystem.MESSAGE.parse("AFK_KICK_MESSAGE", p));
             }
-        }, 1200, 1200); //every minute
+        } else if (currentTime - lastMovementTime > 9 * 60000) {
+            BauSystem.MESSAGE.broadcast("AFK_WARNING_MESSAGE");
+        }
     }
 
     @EventHandler

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

@@ -28,6 +28,7 @@ import de.steamwar.bausystem.utils.bossbar.BossBarService;
 import de.steamwar.linkage.Linked;
 import de.steamwar.network.packets.PacketHandler;
 import de.steamwar.network.packets.server.BaumemberUpdatePacket;
+import de.steamwar.sql.BauweltMember;
 import io.papermc.paper.event.player.PlayerPickBlockEvent;
 import org.bukkit.Bukkit;
 import org.bukkit.boss.BarColor;
@@ -57,6 +58,8 @@ public class BauMemberUpdate extends PacketHandler implements Listener {
     }
 
     public static void baumemberUpdate() {
+        // Packet handlers run in no guaranteed order, so don't rely on CoreNetworkHandler having cleared the cache yet.
+        BauweltMember.clear();
         Set<Player> newSpectator = new HashSet<>();
         Set<Player> newBuilder = new HashSet<>();
         Bukkit.getOnlinePlayers().forEach(player -> {

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

@@ -22,10 +22,11 @@ package de.steamwar.bausystem.features.world;
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.Permission;
 import de.steamwar.bausystem.config.BauServer;
+import de.steamwar.bausystem.features.techhider.HidingRule;
 import de.steamwar.bausystem.utils.BauMemberUpdateEvent;
 import de.steamwar.linkage.Linked;
 import de.steamwar.sql.BauweltMember;
-import de.steamwar.techhider.legacy.TechHider;
+import de.steamwar.techhider.ObfuscationConfig;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
@@ -41,14 +42,18 @@ import org.bukkit.event.entity.EntityPickupItemEvent;
 import org.bukkit.event.player.*;
 import org.bukkit.util.Vector;
 
+import java.util.Collections;
 import java.util.HashSet;
+import java.util.List;
 import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
 
 @Linked
 public class SpectatorListener implements Listener {
 
-    private static final TechHider techHider;
-    private static final Set<Player> NO_TECHHIDER = new HashSet<>();
+    private static final HidingRule SPECTATOR_RULE;
+    // Read on netty threads by the BauTechHider
+    private static final Set<Player> NO_TECHHIDER = ConcurrentHashMap.newKeySet();
 
     static {
         Set<Material> materials = new HashSet<>();
@@ -99,19 +104,12 @@ public class SpectatorListener implements Listener {
         materials.add(Material.WATER);
         materials.remove(Material.BARRIER);
         materials.remove(Material.STONE);
-        techHider = new TechHider((TechHider.LocationEvaluator) (player, i, i1) -> {
-            return Permission.BUILD.hasPermission(player) || NO_TECHHIDER.contains(player);
-        }, Material.END_STONE, materials, new HashSet<>());
+        SPECTATOR_RULE = HidingRule.everywhere(new ObfuscationConfig(Material.END_STONE, materials, Collections.emptySet()));
     }
 
-    private static void enableOrDisableTechhider() {
-        boolean enable = Bukkit.getOnlinePlayers()
-                .stream()
-                .anyMatch(player -> !(Permission.BUILD.hasPermission(player) || NO_TECHHIDER.contains(player)));
-        if (enable) {
-            techHider.enable();
-        } else {
-            techHider.disable();
+    public void addHidingRules(Player player, List<HidingRule> rules) {
+        if (!(Permission.BUILD.hasPermission(player) || NO_TECHHIDER.contains(player))) {
+            rules.add(SPECTATOR_RULE);
         }
     }
 
@@ -122,7 +120,6 @@ public class SpectatorListener implements Listener {
             NO_TECHHIDER.add(player);
         }
         resendChunks(player);
-        enableOrDisableTechhider();
     }
 
     private static void resendChunks(Player player) {
@@ -141,7 +138,6 @@ public class SpectatorListener implements Listener {
 
     @EventHandler
     public void onPlayerJoin(PlayerJoinEvent event) {
-        enableOrDisableTechhider();
         if (BauSystem.DEV_SERVER) return;
         if (event.getPlayer().getUniqueId().equals(BauServer.getInstance().getOwner())) {
             return;
@@ -163,7 +159,6 @@ public class SpectatorListener implements Listener {
 
     @EventHandler
     public void onBauMemberUpdate(BauMemberUpdateEvent event) {
-        enableOrDisableTechhider();
         if (!anySupervisorOnline(null) && !BauSystem.DEV_SERVER) {
             Bukkit.getOnlinePlayers().forEach(player -> {
                 player.kickPlayer("");
@@ -180,7 +175,6 @@ public class SpectatorListener implements Listener {
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent event) {
         NO_TECHHIDER.remove(event.getPlayer());
-        Bukkit.getScheduler().runTaskLater(BauSystem.getInstance(), SpectatorListener::enableOrDisableTechhider, 1);
         if (BauSystem.DEV_SERVER) return;
         if (!anySupervisorOnline(event.getPlayer())) {
             Bukkit.getOnlinePlayers().forEach(player -> {

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

@@ -21,14 +21,15 @@ package de.steamwar.bausystem.features.xray;
 
 import com.comphenix.tinyprotocol.TinyProtocol;
 import de.steamwar.bausystem.BauSystem;
+import de.steamwar.bausystem.features.hullhider.HullHiderCommand;
+import de.steamwar.bausystem.features.techhider.HidingRule;
 import de.steamwar.bausystem.features.techhider.TechHiderCommand;
 import de.steamwar.bausystem.region.Region;
-import de.steamwar.bausystem.utils.ScoreboardElement;
 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 de.steamwar.techhider.ObfuscationConfig;
 import net.md_5.bungee.api.ChatMessageType;
 import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
 import net.minecraft.server.level.ServerPlayer;
@@ -43,22 +44,27 @@ import org.bukkit.event.player.PlayerInteractEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 
 import java.util.*;
+import java.util.concurrent.ConcurrentHashMap;
 import java.util.function.BiFunction;
 
 @Linked
-public class XrayCommand extends SWCommand implements Listener, ScoreboardElement {
+public class XrayCommand extends SWCommand implements Listener {
 
     public XrayCommand() {
         super("xray");
     }
 
-    private Map<Region, Optional<TechHider>> techHiders = new HashMap<>();
+    // Read on netty threads by the BauTechHider and the movement filter
+    private Map<Region, Optional<HidingRule>> hidingRules = new ConcurrentHashMap<>();
     private Map<Region, Set<Material>> xrayedBlocks = new HashMap<>();
-    private Map<Region, Set<Player>> hidden = new HashMap<>();
+    private Map<Region, Set<Player>> hidden = new ConcurrentHashMap<>();
 
     @LinkedInstance
     public TechHiderCommand techHiderCommand;
 
+    @LinkedInstance
+    public HullHiderCommand hullHiderCommand;
+
     @Register(description = "XRAY_HELP")
     public void toggleHider(@Validator Player player) {
         Region region = Region.getRegion(player.getLocation());
@@ -67,23 +73,24 @@ public class XrayCommand extends SWCommand implements Listener, ScoreboardElemen
             return;
         }
 
-        Optional<TechHider> techHider = techHiders.computeIfAbsent(region, rg -> {
+        Optional<HidingRule> hidingRule = hidingRules.computeIfAbsent(region, rg -> {
             if (!region.getGameModeConfig().Techhider.Active) {
                 return Optional.empty();
             }
 
-            hidden.put(rg, new HashSet<>());
+            hidden.put(rg, ConcurrentHashMap.newKeySet());
 
             Set<Material> blocks = new HashSet<>(Arrays.asList(region.getGameModeConfig().Techhider.ObfuscateWith));
             if (blocks.contains(Material.END_STONE)) blocks.add(Material.END_STONE_BRICKS);
             xrayedBlocks.put(region, blocks);
-            return Optional.of(createXray(rg, blocks));
+            return Optional.of(HidingRule.of(rg.getBuildArea(), new ObfuscationConfig(Material.STRUCTURE_VOID, blocks, Collections.emptySet())));
         });
-        if (!techHider.isPresent()) {
+        if (!hidingRule.isPresent()) {
             return;
         }
 
         techHiderCommand.disable(region, player);
+        hullHiderCommand.disable(region, player);
         if (hidden.get(region).contains(player)) {
             hidden.get(region).remove(player);
             BauSystem.MESSAGE.sendPrefixless("XRAY_OFF", player, ChatMessageType.ACTION_BAR);
@@ -139,13 +146,12 @@ public class XrayCommand extends SWCommand implements Listener, ScoreboardElemen
         }
     }
 
-    private TechHider createXray(Region rg, Set<Material> obfuscate) {
-        TechHider current = new TechHider((TechHider.LocationEvaluator) (p, cX, cY) -> {
-            if (rg.getBuildArea().isChunkOutside(cX, cY)) return true;
-            return !hidden.get(rg).contains(p);
-        }, Material.STRUCTURE_VOID, obfuscate, new HashSet<>());
-        current.enable();
-        return current;
+    public void addHidingRules(Player player, List<HidingRule> rules) {
+        hidden.forEach((region, players) -> {
+            if (players.contains(player)) {
+                hidingRules.getOrDefault(region, Optional.empty()).ifPresent(rules::add);
+            }
+        });
     }
 
     @EventHandler
@@ -160,19 +166,7 @@ public class XrayCommand extends SWCommand implements Listener, ScoreboardElemen
         });
     }
 
-    @Override
-    public ScoreboardGroup getGroup() {
-        return ScoreboardGroup.OTHER;
-    }
-
-    @Override
-    public int order() {
-        return 0;
-    }
-
-    @Override
-    public String get(Region region, Player p) {
-        if (!hidden.getOrDefault(region, Collections.emptySet()).contains(p)) return null;
-        return "§e" + BauSystem.MESSAGE.parse("SCOREBOARD_XRAY", p);
+    public boolean isActive(Region region, Player player) {
+        return hidden.getOrDefault(region, Collections.emptySet()).contains(player);
     }
 }

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

@@ -20,78 +20,39 @@
 package de.steamwar.bausystem.region;
 
 import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.worlddata.WorldData;
 import de.steamwar.sql.SchematicNode;
 import lombok.NonNull;
-import yapion.hierarchy.types.YAPIONObject;
 
-import java.util.ArrayList;
 import java.util.HashMap;
-import java.util.List;
 import java.util.Map;
-import java.util.function.Function;
 
 public abstract class RegionData {
 
-    private final List<Property<?, ?>> properties = new ArrayList<>();
-
-    protected final YAPIONObject data;
-    protected final YAPIONObject flagData;
+    protected final WorldData.RegionEntry data;
+    protected final Map<String, String> flagData;
     protected final Runnable onChange;
     protected final Map<Flag<?>, Flag.Value<?>> flagMap = new HashMap<>();
 
-    private final class Property<T, K> {
-        private final String field;
-        private final Function<K, T> loader;
-        private final Function<T, K> writer;
+    private SchematicNode testblockSchematic;
 
-        private T value;
-
-        public Property(String field, Function<K, T> loader, Function<T, K> writer) {
-            this.field = field;
-            this.loader = loader;
-            this.writer = writer;
-            properties.add(this);
-        }
-
-        public void load() {
-            if (flagData.containsKey(field)) {
-                value = loader.apply(flagData.getPlainValue(field));
-            } else {
-                value = null;
-            }
-        }
-
-        public T get() {
-            return value;
-        }
-
-        public void set(T value) {
-            this.value = value;
-            if (value == null) {
-                flagData.remove(field);
-            } else {
-                flagData.put(field, writer.apply(value));
-            }
-        }
-    }
-
-    private Property<SchematicNode, Integer> testblockSchematic = new Property<>("testblockSchematic", SchematicNode::byId, SchematicNode::getId);
-
-    protected RegionData(YAPIONObject data, Runnable onChange) {
+    protected RegionData(WorldData.RegionEntry data, Runnable onChange) {
         this.data = data;
-        this.flagData = data.getObjectOrSetDefault("flagStorage", new YAPIONObject());
+        this.flagData = data.getFlags();
         this.onChange = onChange;
         initialize();
         for (final Flag flag : Flag.getFlags()) {
             if (!has(flag).isWritable()) continue;
             try {
-                String s = flagData.getPlainValue(flag.name());
+                String s = flagData.get(flag.name());
                 flagMap.put(flag, flag.valueOfValue(s));
             } catch (Exception e) {
                 flagMap.put(flag, (Flag.Value<?>) flag.getDefaultValue());
             }
         }
-        properties.forEach(Property::load);
+        if (data.getTestblockSchematic() != null) {
+            testblockSchematic = SchematicNode.byId(data.getTestblockSchematic());
+        }
     }
 
     protected void initialize() {
@@ -126,7 +87,8 @@ public abstract class RegionData {
                 flagData.remove(flag.name());
             }
         }
-        properties.forEach(property -> property.set(null));
+        testblockSchematic = null;
+        data.setTestblockSchematic(null);
         onChange.run();
     }
 
@@ -135,11 +97,12 @@ public abstract class RegionData {
     }
 
     public SchematicNode getTestblockSchematic() {
-        return testblockSchematic.get();
+        return testblockSchematic;
     }
 
     public void setTestblockSchematic(SchematicNode schematic) {
-        testblockSchematic.set(schematic);
+        testblockSchematic = schematic;
+        data.setTestblockSchematic(schematic == null ? null : schematic.getId());
         onChange.run();
     }
 

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/region/flags/Flag.java

@@ -44,6 +44,8 @@ public final class Flag<T extends Enum<T> & Flag.Value<T>> implements EnumDispla
     public static final Flag<TestblockMode> TESTBLOCK = new Flag<>("TESTBLOCK", "FLAG_TESTBLOCK", TestblockMode.class, TestblockMode.NO_VALUE);
     public static final Flag<ChangedMode> CHANGED = new Flag<>("CHANGED", "FLAG_CHANGED", ChangedMode.class, ChangedMode.NO_CHANGE);
     public static final Flag<WaterDestroyMode> WATER_DESTROY = new Flag<>("WATER_DESTROY", "FLAG_WATER_DESTROY", WaterDestroyMode.class, WaterDestroyMode.ALLOW);
+    public static final Flag<WindChargeInteractMode> WIND_CHARGE_INTERACT = new Flag<>("WINDCHARGE_INTERACT", "FLAG_WINDCHARGE_INTERACT", WindChargeInteractMode.class, WindChargeInteractMode.ALLOW);
+    public static final Flag<ProjectileStopperMode> PROJECTILE_STOPPER = new Flag<>("PROJECTILE_STOPPER", "FLAG_PROJECTILE_STOPPER", ProjectileStopperMode.class, ProjectileStopperMode.ENABLED);
 
     private String name;
     private int ordinal;

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/region/flags/ProjectileStopperMode.java

@@ -0,0 +1,52 @@
+/*
+ *   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.region.flags;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum ProjectileStopperMode implements Flag.Value<ProjectileStopperMode> {
+    ENABLED("FLAG_PROJECTILE_STOPPER_ENABLED"),
+    DISABLED("FLAG_PROJECTILE_STOPPER_DISABLED");
+
+    private static WindChargeInteractMode[] values;
+    private final String chatValue;
+
+    @Override
+    public ProjectileStopperMode[] getValues() {
+        return ProjectileStopperMode.values();
+    }
+
+    @Override
+    public ProjectileStopperMode getValue() {
+        return this;
+    }
+
+    @Override
+    public ProjectileStopperMode getValueOf(final String name) {
+        try {
+            return ProjectileStopperMode.valueOf(name.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            return ProjectileStopperMode.ENABLED;
+        }
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/region/flags/WindChargeInteractMode.java

@@ -0,0 +1,53 @@
+/*
+ *   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.region.flags;
+
+import lombok.AllArgsConstructor;
+import lombok.Getter;
+
+@Getter
+@AllArgsConstructor
+public enum WindChargeInteractMode implements Flag.Value<WindChargeInteractMode> {
+
+    ALLOW("FLAG_WINDCHARGE_INTERACT_ALLOW"),
+    DENY("FLAG_WINDCHARGE_INTERACT_DENY");
+
+    private static WindChargeInteractMode[] values;
+    private final String chatValue;
+
+    @Override
+    public WindChargeInteractMode[] getValues() {
+        return WindChargeInteractMode.values();
+    }
+
+    @Override
+    public WindChargeInteractMode getValue() {
+        return this;
+    }
+
+    @Override
+    public WindChargeInteractMode getValueOf(final String name) {
+        try {
+            return WindChargeInteractMode.valueOf(name.toUpperCase());
+        } catch (IllegalArgumentException e) {
+            return WindChargeInteractMode.ALLOW;
+        }
+    }
+}

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

@@ -1,101 +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.worlddata;
-
-import de.steamwar.sql.SteamwarUser;
-import lombok.SneakyThrows;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import yapion.hierarchy.output.FileOutput;
-import yapion.hierarchy.types.YAPIONArray;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.InputStreamCharsets;
-import yapion.parser.YAPIONParser;
-import yapion.parser.options.FileOptions;
-
-import java.io.File;
-import java.util.List;
-
-@UtilityClass
-public class SimulatorData {
-
-    private final File simulatorsDir = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "simulators");
-
-    static {
-        simulatorsDir.mkdirs();
-    }
-
-    @SneakyThrows
-    public YAPIONObject getSimulator(Player player) {
-        File file = getFile(player);
-        if (!file.exists()) {
-            return new YAPIONObject();
-        }
-        return YAPIONParser.parse(file, new FileOptions().charset(InputStreamCharsets.UTF_8));
-    }
-
-    @SneakyThrows
-    private void internalSaveSimulator(Player player, YAPIONObject yapionObject) {
-        File file = getFile(player);
-        yapionObject.toYAPION(new FileOutput(file)).close();
-    }
-
-    @SneakyThrows
-    void saveSimulator(SteamwarUser steamwarUser, YAPIONObject yapionObject) {
-        File file = new File(simulatorsDir, steamwarUser.getId() + ".yapion");
-        yapionObject.toYAPION(new FileOutput(file)).close();
-    }
-
-    public List<String> listSimulator(Player player) {
-        List<String> strings = getSimulator(player).getKeys();
-        strings.remove("");
-        return strings;
-    }
-
-    public void saveSimulator(Player player, String name) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.put(name, yapionObject.getArray("").copy());
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    public void saveSimulator(Player player, YAPIONArray simulator) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.put("", simulator);
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    public void loadSimulator(Player player, String name) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.put("", yapionObject.getArray(name).copy());
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    public void removeSimulator(Player player, String name) {
-        YAPIONObject yapionObject = getSimulator(player);
-        yapionObject.remove(name);
-        internalSaveSimulator(player, yapionObject);
-    }
-
-    private File getFile(Player player) {
-        SteamwarUser steamwarUser = SteamwarUser.get(player.getUniqueId());
-        return new File(simulatorsDir, steamwarUser.getId() + ".yapion");
-    }
-}