Fix NoClipCommand

The line no longer needs start, middle and end parts that were moved
around the player. It is one display that is visible for a player as soon
as any chunk the line passes through is in their view distance.
REntity#canView now receives the chunk positions of player and entity.

.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

@@ -47,7 +47,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/de/steamwar/bausystem/BauSystem.java

@@ -20,8 +20,7 @@
 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;
@@ -36,9 +35,9 @@ 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;
@@ -53,6 +52,8 @@ import org.bukkit.GameRule;
 import org.bukkit.Location;
 import org.bukkit.command.CommandSender;
 import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.java.JavaPlugin;
 import org.bukkit.scheduler.BukkitRunnable;
@@ -65,7 +66,7 @@ import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 import java.util.logging.Level;
 
-public class BauSystem extends JavaPlugin {
+public class BauSystem extends JavaPlugin implements Listener {
 
     // This should be treated as final!
     public static Message MESSAGE;
@@ -109,9 +110,6 @@ public class BauSystem extends JavaPlugin {
                 if (any instanceof PanzernAlgorithm) {
                     Panzern.add((PanzernAlgorithm) any);
                 }
-                if (any instanceof ConfigConverter) {
-                    Config.addConfigConverter((ConfigConverter) any);
-                }
                 if (any instanceof BoundingBoxLoader) {
                     ((BoundingBoxLoader) any).load();
                 }
@@ -149,11 +147,16 @@ public class BauSystem extends JavaPlugin {
         WorldIdentifier.set("bau/" + Core.getVersion() + "/" + identifier);
     }
 
+    @EventHandler
+    public void onCRIUSleep(CRIUSleepEvent event) {
+        RegionSystem.INSTANCE.save();
+    }
+
     @Override
     public void onDisable() {
         linker.unlink();
-        WorldData.write();
-        Config.getInstance().saveAll();
+        RegionSystem.INSTANCE.save();
+        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

@@ -17,17 +17,13 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.bausystem.region;
+package de.steamwar.bausystem.config;
 
-import de.steamwar.core.SWPlayer;
+/**
+ * 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 {
 
-public class DynamicRegionEditor2 implements SWPlayer.Component {
-
-    @Override
-    public void onMount(SWPlayer player) {
-    }
-
-    @Override
-    public void onUnmount(SWPlayer player) {
-    }
+    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/bau/BauInfoBauGuiItem.java

@@ -56,7 +56,6 @@ public class BauInfoBauGuiItem extends BauGuiItem {
         Region region = Region.getRegion(player.getLocation());
         List<String> stringList = new ArrayList<>();
         for (Flag flag : Flag.getFlags()) {
-            if (flag == Flag.CHANGED) continue;
             if (!region.getRegionData().has(flag).isApplicable()) continue;
             FlagOptional<?> value = region.getRegionData().get(flag);
             if (value.isPresent()) {

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/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/rayvisualizer/RayVisualizerCommand.java

@@ -167,7 +167,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 +181,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 +192,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/ColorCommand.java

@@ -63,7 +63,7 @@ public class ColorCommand extends SWCommand {
         }
         region.getRegionData().set(Flag.COLOR, color);
         try {
-            PasteBuilder pasteBuilder = new PasteBuilder()
+            PasteBuilder pasteBuilder = new PasteBuilder(new PasteBuilder.FileProvider(region.getArea().getResetFile()))
                     .ignoreAir(true)
                     .onlyColors(true)
                     .color(color);

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

@@ -60,7 +60,6 @@ public class FireListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.FIRE).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.FIRE).isWithDefault(FireMode.DENY)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.FIRE.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.FIRE).getWithDefault().getChatValue(), p);
     }

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

@@ -249,7 +249,6 @@ public class FreezeListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.FREEZE).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.FREEZE).isWithDefault(FreezeMode.INACTIVE)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.FREEZE.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.FREEZE).getWithDefault().getChatValue(), p);
     }

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

@@ -52,7 +52,6 @@ public class ItemsListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.ITEMS).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.ITEMS).isWithDefault(ItemMode.INACTIVE)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.ITEMS.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.ITEMS).getWithDefault().getChatValue(), p);
     }

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

@@ -54,7 +54,6 @@ public class NoGravityListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.NO_GRAVITY).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.NO_GRAVITY).isWithDefault(NoGravityMode.INACTIVE)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.NO_GRAVITY.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.NO_GRAVITY).getWithDefault().getChatValue(), p);
     }

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

@@ -70,7 +70,6 @@ public class ProtectListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.PROTECT).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.PROTECT).isWithDefault(ProtectMode.INACTIVE)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.PROTECT.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.PROTECT).getWithDefault().getChatValue(), p);
     }

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

@@ -30,7 +30,6 @@ import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.features.util.SelectCommand;
 import de.steamwar.bausystem.region.Point;
 import de.steamwar.bausystem.region.Region;
-import de.steamwar.bausystem.region.RegionHistory;
 import de.steamwar.bausystem.region.RegionUtils;
 import de.steamwar.bausystem.region.flags.Flag;
 import de.steamwar.bausystem.shared.Pair;
@@ -72,10 +71,7 @@ public class RegionCommand extends SWCommand {
     @Register(value = "undo", description = "REGION_REGION_HELP_UNDO")
     public void undoCommand(@Validator Player p) {
         Region region = Region.getRegion(p.getLocation());
-        if (region.getHistory() == RegionHistory.EMPTY) {
-            BauSystem.MESSAGE.send("REGION_REGION_NO_REGION", p);
-            return;
-        }
+        if (checkGlobalRegion(region, p)) return;
 
         if (region.getHistory().undo()) {
             RegionUtils.message(region, "REGION_REGION_UNDID");
@@ -87,8 +83,7 @@ public class RegionCommand extends SWCommand {
     @Register(value = "redo", description = "REGION_REGION_HELP_REDO")
     public void redoCommand(@Validator Player p) {
         Region region = Region.getRegion(p.getLocation());
-        if (region.getHistory() == RegionHistory.EMPTY) {
-            BauSystem.MESSAGE.send("REGION_REGION_NO_REGION", p);
+        if (checkGlobalRegion(region, p)) {
             return;
         }
 
@@ -105,7 +100,7 @@ public class RegionCommand extends SWCommand {
         if (checkGlobalRegion(region, p)) return;
 
         try {
-            PasteBuilder pasteBuilder = new PasteBuilder()
+            PasteBuilder pasteBuilder = new PasteBuilder(new PasteBuilder.FileProvider(region.getArea().getResetFile()))
                     .ignoreAir(true)
                     .color(region.getRegionData().get(Flag.COLOR).getWithDefault());
             region.getArea().reset(pasteBuilder, false);
@@ -127,7 +122,7 @@ public class RegionCommand extends SWCommand {
         }
 
         try {
-            PasteBuilder pasteBuilder = new PasteBuilder(PasteBuilder.ClipboardProvider.schematic(node))
+            PasteBuilder pasteBuilder = new PasteBuilder(new PasteBuilder.SchematicProvider(node))
                     .ignoreAir(true)
                     .color(region.getRegionData().get(Flag.COLOR).getWithDefault());
             region.getArea().reset(pasteBuilder, false);
@@ -148,7 +143,7 @@ public class RegionCommand extends SWCommand {
             BauSystem.MESSAGE.send("REGION_REGION_TP_UNKNOWN", p);
             return;
         }
-        p.teleport(region.getBuildArea().getCopyPoint(false).toLocation(p, 0.5, 0, 0.5), PlayerTeleportEvent.TeleportCause.COMMAND);
+        p.teleport(region.getBuildArea().getCopyPoint().toLocation(p, 0.5, 0, 0.5), PlayerTeleportEvent.TeleportCause.COMMAND);
         BauSystem.MESSAGE.send("REGION_REGION_TP_COPY", p);
     }
 
@@ -163,7 +158,7 @@ public class RegionCommand extends SWCommand {
             BauSystem.MESSAGE.send("REGION_REGION_TP_UNKNOWN", p);
             return;
         }
-        p.teleport(region.getTestblockArea().getCopyPoint(false).toLocation(p, 0.5, 0, 0.5), PlayerTeleportEvent.TeleportCause.COMMAND);
+        p.teleport(region.getTestblockArea().getCopyPoint().toLocation(p, 0.5, 0, 0.5), PlayerTeleportEvent.TeleportCause.COMMAND);
         BauSystem.MESSAGE.send("REGION_REGION_TP_TEST_BLOCK", p);
     }
 
@@ -196,7 +191,7 @@ public class RegionCommand extends SWCommand {
                 break;
         }
 
-        Clipboard clipboard = FlatteningWrapper.impl.copy(minPoint, maxPoint, region.getBuildArea().getCopyPoint(false));
+        Clipboard clipboard = FlatteningWrapper.impl.copy(minPoint, maxPoint, region.getBuildArea().getCopyPoint());
         WorldEdit.getInstance()
                 .getSessionManager()
                 .get(BukkitAdapter.adapt(p))
@@ -241,13 +236,13 @@ public class RegionCommand extends SWCommand {
         }
 
         try (EditSession e = WorldEditUtils.getEditSession(p)) {
-            Operations.completeBlindly(clipboardHolder.createPaste(e).ignoreAirBlocks(ignoreAir).to(toBlockVector3(region.getBuildArea().getCopyPoint(false))).build());
+            Operations.completeBlindly(clipboardHolder.createPaste(e).ignoreAirBlocks(ignoreAir).to(toBlockVector3(region.getBuildArea().getCopyPoint())).build());
             WorldEditUtils.addToPlayer(p, e);
 
             if (selectPasted) {
                 Clipboard clipboard = clipboardHolder.getClipboards().get(0);
-                BlockVector3 minPointSelection = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin()).add(toBlockVector3(region.getBuildArea().getCopyPoint(false)));
-                BlockVector3 maxPointSelection = clipboard.getRegion().getMaximumPoint().subtract(clipboard.getOrigin()).add(toBlockVector3(region.getBuildArea().getCopyPoint(false)));
+                BlockVector3 minPointSelection = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin()).add(toBlockVector3(region.getBuildArea().getCopyPoint()));
+                BlockVector3 maxPointSelection = clipboard.getRegion().getMaximumPoint().subtract(clipboard.getOrigin()).add(toBlockVector3(region.getBuildArea().getCopyPoint()));
                 FlatteningWrapper.impl.setSelection(p, Point.fromBlockVector3(minPointSelection), Point.fromBlockVector3(maxPointSelection));
             }
             BauSystem.MESSAGE.send("REGION_REGION_PASTE_DONE", p);

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

@@ -29,6 +29,9 @@ import de.steamwar.bausystem.utils.PasteBuilder;
 import de.steamwar.command.SWCommand;
 import de.steamwar.linkage.Linked;
 import de.steamwar.linkage.LinkedInstance;
+import de.steamwar.sql.Punishment;
+import de.steamwar.sql.SchematicNode;
+import de.steamwar.sql.SteamwarUser;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 
@@ -49,7 +52,7 @@ public class ResetCommand extends SWCommand {
         Region region = regionCheck(p);
         if (region == null) return;
         try {
-            PasteBuilder pasteBuilder = new PasteBuilder()
+            PasteBuilder pasteBuilder = new PasteBuilder(new PasteBuilder.FileProvider(region.getArea().getResetFile()))
                     .color(region.getRegionData().get(Flag.COLOR).getWithDefault());
             region.getArea().reset(pasteBuilder, false);
             region.getRegionData().clear();
@@ -60,6 +63,35 @@ public class ResetCommand extends SWCommand {
         }
     }
 
+    @Register(description = "REGION_RESET_HELP_SCHEMATIC")
+    public void schematicResetCommand(@Validator Player p, SchematicNode node) {
+        Region region = regionCheck(p);
+        if (region == null) return;
+
+        if (!p.getUniqueId().equals(bauServer.getOwner())) {
+            if (Punishment.isPunished(SteamwarUser.get(bauServer.getOwner()), Punishment.PunishmentType.NoSchemReceiving, punishment -> BauSystem.MESSAGE.send("REGION_TB_NO_SCHEMRECEIVING", p, punishment.getEndTime()))) {
+                return;
+            }
+            if (Punishment.isPunished(SteamwarUser.get(p.getUniqueId()), Punishment.PunishmentType.NoSchemSharing, punishment -> BauSystem.MESSAGE.send("REGION_TB_NO_SCHEMSHARING", p, punishment.getEndTime()))) {
+                return;
+            }
+        }
+
+        if (node.isDir()) {
+            BauSystem.MESSAGE.send("ONLY_SCHEMS", p);
+            return;
+        }
+        try {
+            PasteBuilder pasteBuilder = new PasteBuilder(new PasteBuilder.SchematicProvider(node))
+                    .color(region.getRegionData().get(Flag.COLOR).getWithDefault());
+            region.getArea().reset(pasteBuilder, true);
+            RegionUtils.message(region, "REGION_RESET_RESETED");
+        } catch (SecurityException e) {
+            BauSystem.MESSAGE.send("REGION_RESET_ERROR", p);
+            Bukkit.getLogger().log(Level.WARNING, "Failed reset", e);
+        }
+    }
+
     private Region regionCheck(Player player) {
         Region region = Region.getRegion(player.getLocation());
         if (region == RegionSystem.INSTANCE.getGlobalRegion()) {

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

@@ -82,7 +82,6 @@ public class TNTListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.TNT).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.TNT).isWithDefault(TNTMode.ALLOW)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.TNT.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.TNT).getWithDefault().getChatValue(), p);
     }

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

@@ -21,11 +21,9 @@ package de.steamwar.bausystem.features.region;
 
 import de.steamwar.bausystem.BauSystem;
 import de.steamwar.bausystem.config.BauServer;
-import de.steamwar.bausystem.region.Point;
 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.TestblockMode;
 import de.steamwar.bausystem.region.utils.RegionExtensionType;
 import de.steamwar.bausystem.utils.PasteBuilder;
 import de.steamwar.command.PreviousArguments;
@@ -57,12 +55,12 @@ public class TestblockCommand extends SWCommand {
         super("testblock", "tb", "dummy");
     }
 
-    @Register(description = {"REGION_TB_HELP_RESET", "REGION_TB_HELP_RESET_EXTENSION"})
+    @Register
     public void schematicTestblockCommand(@Validator Player p, TestblockParameterType... testblockParameterTypes) {
         schematicTestblockCommand(p, null, testblockParameterTypes);
     }
 
-    @Register(description = {"REGION_TB_HELP_SCHEMATIC", "REGION_TB_HELP_SCHEMATIC_EXTENSION"})
+    @Register
     public void schematicTestblockCommand(@Validator Player p, @Mapper("withPublic") SchematicNode node, TestblockParameterType... testblockParameterTypes) {
         Set<TestblockParameterType> testblockParameterTypesSet = new HashSet<>(Arrays.asList(testblockParameterTypes));
         boolean isExtension = testblockParameterTypesSet.contains(TestblockParameterType.EXTENSION);
@@ -108,7 +106,13 @@ public class TestblockCommand extends SWCommand {
             region.getRegionData().setTestblockSchematic(node);
         }
 
-        PasteBuilder.ClipboardProvider clipboardProvider = node == null ? PasteBuilder.ClipboardProvider.EMPTY : PasteBuilder.ClipboardProvider.schematic(node);
+        PasteBuilder.ClipboardProvider clipboardProvider;
+        if (node == null) {
+            clipboardProvider = new PasteBuilder.FileProvider(region.getTestblockArea().getResetFile());
+        } else {
+            clipboardProvider = new PasteBuilder.SchematicProvider(node);
+        }
+
         try {
             PasteBuilder pasteBuilder = new PasteBuilder(clipboardProvider)
                     .ignoreAir(ignoreAir)
@@ -169,17 +173,6 @@ public class TestblockCommand extends SWCommand {
 
     private Region regionCheck(Player player) {
         Region region = Region.getRegion(player.getLocation());
-        if (region.getRegionData().has(Flag.TESTBLOCK).isWritable() && region.getRegionData().get(Flag.TESTBLOCK).isWithDefault(TestblockMode.NO_VALUE)) {
-            Point minPoint = region.getArea().getMinPoint(false);
-            Point maxPoint = region.getArea().getMaxPoint(false);
-            // TODO: Check if empty!
-            int half = minPoint.getZ() + (maxPoint.getZ() - minPoint.getZ()) / 2;
-            if (player.getLocation().getBlockZ() <= half) {
-                region.getRegionData().set(Flag.TESTBLOCK, TestblockMode.SOUTH);
-            } else {
-                region.getRegionData().set(Flag.TESTBLOCK, TestblockMode.NORTH);
-            }
-        }
         if (region.getTestblockArea().isEmpty()) {
             BauSystem.MESSAGE.send("REGION_TB_NO_REGION", player);
             return null;

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

@@ -1,49 +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.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.TestblockMode;
-import de.steamwar.bausystem.utils.ScoreboardElement;
-import de.steamwar.linkage.Linked;
-import org.bukkit.entity.Player;
-
-@Linked
-public class TestblockScoreboardElement implements ScoreboardElement {
-
-    @Override
-    public ScoreboardGroup getGroup() {
-        return ScoreboardGroup.REGION;
-    }
-
-    @Override
-    public int order() {
-        return 6;
-    }
-
-    @Override
-    public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.TESTBLOCK).notVisibleInScoreboard()) return null;
-        if (region.getRegionData().get(Flag.TESTBLOCK).is(TestblockMode.NO_VALUE)) return null;
-        return "§e" + BauSystem.MESSAGE.parse(Flag.TESTBLOCK.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.TESTBLOCK).getWithDefault().getChatValue(), p);
-    }
-}

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

@@ -53,7 +53,6 @@ public class WaterDestroyListener implements Listener, ScoreboardElement {
 
     @Override
     public String get(Region region, Player p) {
-        if (region.getRegionData().has(Flag.WATER_DESTROY).notVisibleInScoreboard()) return null;
         if (region.getRegionData().get(Flag.WATER_DESTROY).isWithDefault(WaterDestroyMode.ALLOW)) return null;
         return "§e" + BauSystem.MESSAGE.parse(Flag.WATER_DESTROY.getChatValue(), p) + "§8: " + BauSystem.MESSAGE.parse(region.getRegionData().get(Flag.WATER_DESTROY).getWithDefault().getChatValue(), p);
     }

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/region/items/ResetBauGuiItem.java

@@ -50,8 +50,16 @@ public class ResetBauGuiItem extends BauGuiItem {
 
     @Override
     public boolean click(ClickType click, Player p) {
-        p.closeInventory();
-        resetCommand.genericResetCommand(p);
+        if (click == ClickType.LEFT) {
+            p.closeInventory();
+            resetCommand.genericResetCommand(p);
+        } else {
+            SchematicSelector selector = new SchematicSelector(p, SchematicSelector.selectSchematic(), node -> {
+                p.closeInventory();
+                resetCommand.schematicResetCommand(p, node);
+            });
+            selector.open();
+        }
         return false;
     }
 

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/script/lua/libs/RegionLib.java

@@ -79,12 +79,12 @@ public class RegionLib implements LuaLib {
         Loader loader = Loader.getLoader(player);
         table.set("loader", getter(() -> loader == null ? "OFF" : loader.getStage().name()));
 
-        table.set("copyPoint", getter(() -> toPos(region.get().getBuildArea().getCopyPoint(false))));
+        table.set("copyPoint", getter(() -> toPos(region.get().getBuildArea().getCopyPoint())));
         table.set("minPointBuild", getter(() -> toPos(region.get().getBuildArea().getMinPoint(false))));
         table.set("maxPointBuild", getter(() -> toPos(region.get().getBuildArea().getMinPoint(false))));
         table.set("minPointBuildExtension", getter(() -> toPos(region.get().getBuildArea().getMinPoint(true))));
         table.set("maxPointBuildExtension", getter(() -> toPos(region.get().getBuildArea().getMinPoint(true))));
-        table.set("testblockPoint", getter(() -> toPos(region.get().getTestblockArea().getCopyPoint(false))));
+        table.set("testblockPoint", getter(() -> toPos(region.get().getTestblockArea().getCopyPoint())));
         table.set("minPointTestblock", getter(() -> toPos(region.get().getTestblockArea().getMinPoint(false))));
         table.set("maxPointTestblock", getter(() -> toPos(region.get().getTestblockArea().getMinPoint(false))));
         table.set("minPointTestblockExtension", getter(() -> toPos(region.get().getTestblockArea().getMinPoint(true))));

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/execute/StabFinalizer.java

@@ -33,7 +33,7 @@ public class StabFinalizer extends StabStep {
     @Override
     protected void start() {
         try {
-            PasteBuilder.ClipboardProvider clipboardProvider = PasteBuilder.ClipboardProvider.clipboard(data.clipboard);
+            PasteBuilder.ClipboardProvider clipboardProvider = new PasteBuilder.ClipboardProviderImpl(data.clipboard);
             PasteBuilder pasteBuilder = new PasteBuilder(clipboardProvider);
             if (data.region.getRegionData().has(Flag.COLOR).isReadable()) {
                 pasteBuilder.color(data.region.getRegionData().get(Flag.COLOR).getWithDefault());

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/execute/StabGenerator.java

@@ -72,7 +72,7 @@ public class StabGenerator extends StabStep implements Listener {
     @Override
     protected void start() {
         try {
-            PasteBuilder.ClipboardProvider clipboardProvider = PasteBuilder.ClipboardProvider.clipboard(data.clipboard);
+            PasteBuilder.ClipboardProvider clipboardProvider = new PasteBuilder.ClipboardProviderImpl(data.clipboard);
             PasteBuilder pasteBuilder = new PasteBuilder(clipboardProvider);
             if (data.region.getRegionData().has(Flag.COLOR).isReadable()) {
                 pasteBuilder.color(data.region.getRegionData().get(Flag.COLOR).getWithDefault());

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/simulator/execute/StabSetup.java

@@ -72,7 +72,7 @@ public class StabSetup extends StabStep {
         if (TraceRecorder.instance.isAutoTraceEnabledInRegion(data.region)) {
             TraceRecorder.instance.removeAutoTraceRegion(data.region);
         }
-        data.clipboard = FlatteningWrapper.impl.copy(data.region.getTestblockArea().getMinPoint(true), data.region.getTestblockArea().getMaxPoint(true), data.region.getTestblockArea().getCopyPoint(false));
+        data.clipboard = FlatteningWrapper.impl.copy(data.region.getTestblockArea().getMinPoint(true), data.region.getTestblockArea().getMaxPoint(true), data.region.getTestblockArea().getCopyPoint());
 
         new StabDirection(data);
     }

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

@@ -0,0 +1,64 @@
+/*
+ *   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 de.steamwar.bausystem.features.slaves.laufbau.converter.LaufbauConfigV1ToV2Converter;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+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 = 2;
+
+    /**
+     * LaufbauConfigV1 is stored as Base64 of gzipped YAPION, the current version as JSON
+     */
+    public static final ConfigStore<LaufbauConfig> STORE = new ConfigStore<>(LaufbauConfig.class, VERSION, LaufbauConfig::new)
+            .legacy(s -> !s.startsWith("{"), LaufbauConfigV1::parse)
+            .converter(new LaufbauConfigV1ToV2Converter())
+            .userConfig("bausystem-laufbau")
+            .removeIf(config -> config.getDeactivated().isEmpty());
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Identifiers of the deactivated {@link BlockBoundingBox}es, see {@link LaufbauUtils#identifier(BlockBoundingBox)}
+     */
+    protected Set<String> deactivated = new HashSet<>();
+}

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

@@ -0,0 +1,65 @@
+/*
+ *   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.VersionedConfig;
+import de.steamwar.bausystem.config.legacy.YapionReader;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
+
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.UncheckedIOException;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.zip.GZIPInputStream;
+
+/**
+ * The legacy laufbau config that was stored as Base64 of the gzipped YAPION,
+ * an object with the deactivated identifiers as keys.
+ */
+@Getter
+@Setter
+@Deprecated
+public class LaufbauConfigV1 implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    protected Set<String> deactivated = new HashSet<>();
+
+    public static LaufbauConfigV1 parse(String base64) {
+        String yapion;
+        try (InputStream inputStream = new GZIPInputStream(new ByteArrayInputStream(Base64.getDecoder().decode(base64)))) {
+            yapion = new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            throw new UncheckedIOException(e);
+        }
+        LaufbauConfigV1 config = new LaufbauConfigV1();
+        config.deactivated.addAll(YapionReader.parse(yapion).keySet());
+        return config;
+    }
+}

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

@@ -20,63 +20,22 @@
 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.Set;
 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));
     }
@@ -123,7 +82,7 @@ public class LaufbauUtils {
             return false;
         }
         String identifier = identifier(bb);
-        return SWPlayer.of(p).getComponentOrDefault(LaufbauComponent.class, LaufbauComponent::new).yapionObject.containsKey(identifier);
+        return LaufbauConfig.STORE.get(p).getDeactivated().contains(identifier);
     }
 
     @SneakyThrows
@@ -132,11 +91,9 @@ public class LaufbauUtils {
             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());
+        Set<String> deactivated = LaufbauConfig.STORE.get(p).getDeactivated();
+        if (!deactivated.remove(identifier)) {
+            deactivated.add(identifier);
         }
     }
 }

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

@@ -17,19 +17,24 @@
  *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-package de.steamwar.bausystem.region.dynamic.modes.microwargear_7;
+package de.steamwar.bausystem.features.slaves.laufbau.converter;
 
-import de.steamwar.sql.GameModeConfig;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Material;
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.features.slaves.laufbau.LaufbauConfig;
+import de.steamwar.bausystem.features.slaves.laufbau.LaufbauConfigV1;
 
-@UtilityClass
-public class MiWG7Utils {
+@Deprecated
+public class LaufbauConfigV1ToV2Converter implements ConfigConverter<LaufbauConfigV1, LaufbauConfig> {
 
-    public static final GameModeConfig<Material, String> GAME_MODE_CONFIG;
+    @Override
+    public int version() {
+        return LaufbauConfigV1.VERSION;
+    }
 
-    static {
-        GameModeConfig<Material, String> config = GameModeConfig.getByGameName("MicroWarGear");
-        GAME_MODE_CONFIG = config != null ? config : GameModeConfig.getDefaults();
+    @Override
+    public LaufbauConfig convert(LaufbauConfigV1 old) {
+        LaufbauConfig config = new LaufbauConfig();
+        config.getDeactivated().addAll(old.getDeactivated());
+        return config;
     }
 }

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/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/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,122 +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;
-
+            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)) {
@@ -145,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);
@@ -153,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

@@ -22,11 +22,9 @@ package de.steamwar.bausystem.features.warp;
 import de.steamwar.bausystem.region.RegionSystem;
 import de.steamwar.bausystem.worlddata.WorldData;
 import lombok.Getter;
-import lombok.Setter;
 import org.bukkit.*;
 import org.bukkit.entity.Player;
 import org.bukkit.event.player.PlayerTeleportEvent;
-import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.*;
 
@@ -36,20 +34,14 @@ public class Warp {
     private static Map<String, Warp> warpMap = new HashMap<>();
 
     public static void enable() {
-        Warp worldSpawn = new Warp("WorldSpawn") {
-            @Override
-            public Location getLocation() {
-                return RegionSystem.INSTANCE.getWorldSpawn();
-            }
-        };
+        Warp worldSpawn = new Warp("WorldSpawn");
+        worldSpawn.setLocation(RegionSystem.INSTANCE.getWorldSpawn());
         worldSpawn.setMat(Material.NETHER_STAR);
         warpMap.put("WorldSpawn", worldSpawn);
     }
 
     private String name;
-    @Setter
     private Location location;
-    @Setter
     private Material mat;
 
     private Warp(String name) {
@@ -63,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() {
@@ -98,13 +85,21 @@ public class Warp {
         return warpMap.get(name);
     }
 
+    public void setMat(Material mat) {
+        this.mat = mat;
+    }
+
+    public void setLocation(Location location) {
+        this.location = location;
+    }
+
     public void delete() {
         warpMap.remove(name);
-        WorldData.getWarpData().remove(name);
+        WorldData.STORE.get().getWarps().remove(name);
     }
 
     public void teleport(Player player) {
-        player.teleport(getLocation(), PlayerTeleportEvent.TeleportCause.PLUGIN);
-        player.playSound(getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, SoundCategory.PLAYERS, 1, 1);
+        player.teleport(location, PlayerTeleportEvent.TeleportCause.PLUGIN);
+        player.playSound(location, Sound.ENTITY_ENDERMAN_TELEPORT, SoundCategory.PLAYERS, 1, 1);
     }
 }

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/warp/WarpListener.java

@@ -99,10 +99,10 @@ public class WarpListener implements Listener {
             });
             Region region = Region.getRegion(p.getLocation());
             if (!region.getBuildArea().isEmpty()) {
-                locations.put("Copy", region.getBuildArea().getCopyPoint(false).toLocation(p).add(0.5, 0, 0.5));
+                locations.put("Copy", region.getBuildArea().getCopyPoint().toLocation(p).add(0.5, 0, 0.5));
             }
             if (!region.getTestblockArea().isEmpty()) {
-                locations.put("TestBlock", region.getTestblockArea().getCopyPoint(false).toLocation(p).add(0.5, 0, 0.5));
+                locations.put("TestBlock", region.getTestblockArea().getCopyPoint().toLocation(p).add(0.5, 0, 0.5));
             }
         }
 

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

@@ -119,8 +119,11 @@ public class BauScoreboard implements Listener {
             @Override
             public String getTitle() {
                 Region region = Region.getRegion(player.getLocation());
-                if (region.getRegionData().has(Flag.COLOR).notVisibleInScoreboard()) return "§eSteam§8War";
-                String colorCode = "§" + region.getRegionData().get(Flag.COLOR).getWithDefault().getColorCode();
+                if (region.getType().isGlobal()) return "§eSteam§8War";
+                String colorCode = "§e";
+                if (region.getRegionData().has(Flag.COLOR).isReadable()) {
+                    colorCode = "§" + region.getRegionData().get(Flag.COLOR).orElse(ColorMode.PINK).getColorCode();
+                }
                 return colorCode + "■ §eSteam§8War " + colorCode + "■"; // ■
             }
         });
@@ -128,6 +131,7 @@ public class BauScoreboard implements Listener {
 
     @EventHandler
     public void onPlayerQuit(PlayerQuitEvent event) {
+        SWScoreboard.impl.removeScoreboard(event.getPlayer());
         ADDITIONAL_SCOREBOARD_LINES.remove(event.getPlayer());
     }
 }

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

@@ -28,7 +28,6 @@ import org.bukkit.scheduler.BukkitRunnable;
 
 import java.util.Iterator;
 import java.util.Optional;
-import java.util.stream.Collectors;
 
 @Linked
 public class BackupScheduler implements Enable {
@@ -44,7 +43,6 @@ public class BackupScheduler implements Enable {
                 Iterator<Region> regionsToBackup = RegionSystem.INSTANCE.getRegions()
                         .filter(region -> region.getRegionData().has(Flag.CHANGED).isReadable())
                         .filter(region -> region.getRegionData().get(Flag.CHANGED).isWithDefault(ChangedMode.HAS_CHANGE))
-                        .collect(Collectors.toList())
                         .iterator();
                 if (!regionsToBackup.hasNext()) return;
                 doBackup(regionsToBackup);

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

@@ -48,18 +48,10 @@ public class Point {
         return new Point(blockVector3.getBlockX(), blockVector3.getBlockY(), blockVector3.getBlockZ());
     }
 
-    public Point add(Point point) {
-        return add(point.x, point.y, point.z);
-    }
-
     public Point add(int x, int y, int z) {
         return new Point(this.x + x, this.y + y, this.z + z);
     }
 
-    public Point subtract(Point point) {
-        return subtract(point.x, point.y, point.z);
-    }
-
     public Point subtract(int x, int y, int z) {
         return new Point(this.x - x, this.y - y, this.z - z);
     }
@@ -68,18 +60,6 @@ public class Point {
         return new Point(x / factor, y / factor, z / factor);
     }
 
-	public Point setX(int x) {
-		return new Point(x, this.y, this.z);
-	}
-
-	public Point setY(int y) {
-		return new Point(this.x, y, this.z);
-	}
-
-	public Point setZ(int z) {
-		return new Point(this.x, this.y, z);
-	}
-
     public Location toLocation(World world) {
         return new Location(world, x, y, z);
     }

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

@@ -24,16 +24,16 @@ import de.steamwar.bausystem.utils.FlatteningWrapper;
 import de.steamwar.bausystem.utils.PasteBuilder;
 import de.steamwar.sql.GameModeConfig;
 import lombok.NonNull;
-import org.bukkit.Bukkit;
 import org.bukkit.Location;
 import org.bukkit.Material;
 
 import javax.annotation.Nullable;
+import java.io.File;
 import java.util.UUID;
 import java.util.function.BiConsumer;
 import java.util.stream.Stream;
 
-public interface Region extends RegionDataStore {
+public interface Region {
 
     static Stream<Region> getRegions() {
         return RegionSystem.INSTANCE.getRegions();
@@ -74,14 +74,11 @@ public interface Region extends RegionDataStore {
     @NonNull
     RegionBackups getBackups();
 
-    abstract class Area {
+    interface Area {
 
-        public static final int WORLD_MIN_Y = 0;
-        public static final int WORLD_MAX_Y = Bukkit.getWorlds().get(0).getMaxHeight();
-
-        public static final Area EMPTY = new Area() {
+        Area EMPTY = new Area() {
             @Override
-            protected boolean isEmptyInternal() {
+            public boolean isEmpty() {
                 return true;
             }
 
@@ -96,7 +93,7 @@ public interface Region extends RegionDataStore {
             }
 
             @Override
-            public Point getCopyPoint(boolean extension) {
+            public Point getCopyPoint() {
                 return Point.ZERO;
             }
 
@@ -105,18 +102,18 @@ public interface Region extends RegionDataStore {
                 return false;
             }
 
-            @Override
-            public boolean inRegion(int x, int z, boolean extension) {
-                return false;
-            }
-
             @Override
             public Clipboard copy(boolean extension) {
                 return null;
             }
 
             @Override
-            public void place(PasteBuilder pasteBuilder, boolean extension) {
+            public File getResetFile() {
+                return null;
+            }
+
+            @Override
+            public void reset(PasteBuilder pasteBuilder, boolean extension) {
             }
 
             @Override
@@ -129,24 +126,20 @@ public interface Region extends RegionDataStore {
             }
         };
 
-        public final boolean isEmpty() {
-            return isEmptyInternal();
-        }
-
-        boolean isEmptyInternal() {
+        default boolean isEmpty() {
             return false;
         }
 
         @NonNull
-        public abstract Point getMinPoint(boolean extension);
+        Point getMinPoint(boolean extension);
 
         @NonNull
-        public abstract Point getMaxPoint(boolean extension);
+        Point getMaxPoint(boolean extension);
 
         @NonNull
-        public abstract Point getCopyPoint(boolean extension);
+        Point getCopyPoint();
 
-        public boolean inRegion(Location location, boolean extension) {
+        default boolean inRegion(Location location, boolean extension) {
             Point minPoint = getMinPoint(extension);
             Point maxPoint = getMaxPoint(extension);
             if (location.getBlockX() < minPoint.getX() || location.getBlockX() > maxPoint.getX()) return false;
@@ -155,26 +148,17 @@ public interface Region extends RegionDataStore {
             return true;
         }
 
-        public boolean inRegion(int x, int z, boolean extension) {
-            Point minPoint = getMinPoint(extension);
-            Point maxPoint = getMaxPoint(extension);
-            if (x < minPoint.getX() || x > maxPoint.getX()) return false;
-            if (z < minPoint.getZ() || z > maxPoint.getZ()) return false;
-            return true;
+        @Nullable
+        default Clipboard copy(boolean extension) {
+            return FlatteningWrapper.impl.copy(getMinPoint(extension), getMaxPoint(extension), getCopyPoint());
         }
 
         @Nullable
-        public Clipboard copy(boolean extension) {
-            return FlatteningWrapper.impl.copy(getMinPoint(extension), getMaxPoint(extension), getCopyPoint(extension));
-        }
+        File getResetFile();
 
-        public void reset(PasteBuilder pasteBuilder, boolean extension) {
-            place(pasteBuilder, extension);
-        }
+        void reset(PasteBuilder pasteBuilder, boolean extension);
 
-        public abstract void place(PasteBuilder pasteBuilder, boolean extension);
-
-        public void forEachChunk(BiConsumer<Integer, Integer> executor) {
+        default void forEachChunk(BiConsumer<Integer, Integer> executor) {
             Point minPoint = getMinPoint(false);
             Point maxPoint = getMaxPoint(false);
             for (int x = (int) Math.floor(minPoint.getX() / 16.0); x <= (int) Math.ceil(maxPoint.getX() / 16.0); x++) {
@@ -184,7 +168,7 @@ public interface Region extends RegionDataStore {
             }
         }
 
-        public boolean isChunkOutside(int chunkX, int chunkZ) {
+        default boolean isChunkOutside(int chunkX, int chunkZ) {
             Point minPoint = getMinPoint(true);
             Point maxPoint = getMaxPoint(true);
             return Math.floor(minPoint.getX() / 16.0) > chunkX || chunkX >= Math.ceil(maxPoint.getX() / 16.0) ||

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

@@ -25,15 +25,11 @@ import lombok.RequiredArgsConstructor;
 
 import javax.annotation.CheckReturnValue;
 import javax.annotation.Nullable;
-import java.time.format.DateTimeFormatter;
 import java.util.List;
 import java.util.Optional;
-import java.util.function.Function;
 
 public interface RegionBackups {
 
-    DateTimeFormatter FORMATTER = DateTimeFormatter.ofPattern("yyyy.MM.dd' 'HH:mm:ss");
-
     @RequiredArgsConstructor
     enum BackupType {
         MANUAL(5),
@@ -43,43 +39,21 @@ public interface RegionBackups {
         public final int maxBackups;
     }
 
+    @RequiredArgsConstructor
     @Getter
-    abstract class Backup implements RegionDataStore, Comparable<Backup> {
+    abstract class Backup {
         @NonNull
-        protected final BackupType type;
+        private final BackupType type;
 
         @NonNull
-        protected final String name;
+        private final String name;
 
         @NonNull
-        protected final RegionData regionData;
-
-        protected Backup(@NonNull BackupType type, @NonNull String name, @NonNull Function<Backup, RegionData> regionDataConstructor) {
-            this.type = type;
-            this.name = name;
-            regionData = regionDataConstructor.apply(this);
-        }
+        private final RegionData data;
 
         @CheckReturnValue
         public abstract boolean load();
 
-        @Override
-        public final void save() {
-        }
-
-        public abstract long getCreationTime();
-
-        @Override
-        public int compareTo(Backup o) {
-            return Long.compare(getCreationTime(), o.getCreationTime());
-        }
-
-        @Override
-        public final void load(RegionData regionData) {
-        }
-
-        @SuppressWarnings("java:S3038") // This forces everybody to implement 'deleteRegion' for Backups!
-        @Override
         public abstract void delete();
     }
 
@@ -90,7 +64,7 @@ public interface RegionBackups {
     List<Backup> list();
 
     @Nullable
-    Backup get(@NonNull String name);
+    Backup get(String name);
 
     RegionBackups EMPTY = new RegionBackups() {
         @Override
@@ -105,7 +79,7 @@ public interface RegionBackups {
 
         @Nullable
         @Override
-        public Backup get(@NonNull String name) {
+        public Backup get(String name) {
             return null;
         }
     };

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

@@ -20,44 +20,44 @@
 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 java.util.*;
-import java.util.function.Function;
-import java.util.stream.Stream;
+import java.util.HashMap;
+import java.util.Map;
 
 public abstract class RegionData {
 
-    protected RegionDataStore store;
-
-    private final List<Property<?, ?>> properties = new ArrayList<>();
-
+    protected final WorldData.RegionEntry data;
+    protected final Map<String, String> flagData;
+    protected final Runnable onChange;
     protected final Map<Flag<?>, Flag.Value<?>> flagMap = new HashMap<>();
-    // TODO: These should be turned into an ECS like System because not every Region has them or should have them!
-    protected final Property<SchematicNode, Integer> testblockSchematic = new Property<>("testblockSchematic", SchematicNode::byId, SchematicNode::getId);
 
-    protected RegionData(RegionDataStore store) {
-        this.store = store;
+    private SchematicNode testblockSchematic;
+
+    protected RegionData(WorldData.RegionEntry data, Runnable onChange) {
+        this.data = data;
+        this.flagData = data.getFlags();
+        this.onChange = onChange;
         initialize();
-        store.load(this);
-    }
-
-    public final void setStore(RegionDataStore store) {
-        this.store = store;
-        store.save();
+        for (final Flag flag : Flag.getFlags()) {
+            if (!has(flag).isWritable()) continue;
+            try {
+                String s = flagData.get(flag.name());
+                flagMap.put(flag, flag.valueOfValue(s));
+            } catch (Exception e) {
+                flagMap.put(flag, (Flag.Value<?>) flag.getDefaultValue());
+            }
+        }
+        if (data.getTestblockSchematic() != null) {
+            testblockSchematic = SchematicNode.byId(data.getTestblockSchematic());
+        }
     }
 
     protected void initialize() {
     }
 
-    /**
-     * All connected Regions are required to have the same type as their RegionData.
-     */
-    protected Stream<Region> connectedRegions() {
-        return Stream.empty();
-    }
-
     @NonNull
     public abstract <T extends Enum<T> & Flag.Value<T>> RegionFlagPolicy has(@NonNull Flag<T> flag);
 
@@ -66,15 +66,11 @@ public abstract class RegionData {
      */
     public final <T extends Enum<T> & Flag.Value<T>> boolean set(@NonNull Flag<T> flag, @NonNull T value) {
         if (has(flag).isWritable()) {
-            boolean needsSave = flagMap.put(flag, value) != value;
-            if (needsSave) store.save();
-
-            connectedRegions().forEach(region -> {
-                if (region.getRegionData().flagMap.put(flag, value) != value) {
-                    region.save();
-                }
-            });
-            return needsSave;
+            if (flagMap.put(flag, value) != value) {
+                flagData.put(flag.name(), value.name());
+                onChange.run();
+                return true;
+            }
         }
         return false;
     }
@@ -85,94 +81,35 @@ public abstract class RegionData {
     }
 
     public final void clear() {
-        Set<Flag> remove = new HashSet<>();
         for (Flag flag : Flag.getFlags()) {
             if (has(flag).isWritable()) {
                 flagMap.remove(flag);
-                remove.add(flag);
+                flagData.remove(flag.name());
             }
         }
-        initialize();
-        properties.forEach(property -> property.set(null));
-        store.save();
-
-        connectedRegions().forEach(region -> {
-            region.getRegionData().flagMap.keySet().removeAll(remove);
-            region.getRegionData().initialize();
-            region.getRegionData().properties.forEach(property -> property.set(null));
-            region.save();
-        });
-    }
-
-    /**
-     * This method only copies all flags and properties from this into other without saving other afterward.
-     * TODO: If {@link #connectedRegions()} is overridden this method will not work correctly!
-     */
-    public final void copyInto(RegionData other) {
-        if (this == other) return;
-        other.flagMap.clear();
-        other.flagMap.putAll(flagMap);
-        // TODO: This might not be correct, needs to be investigated
-        other.properties.clear();
-        other.properties.addAll(properties);
+        testblockSchematic = null;
+        data.setTestblockSchematic(null);
+        onChange.run();
     }
 
     public final Map<Flag<?>, Flag.Value<?>> getBackedMap() {
         return flagMap;
     }
 
-    public final List<Property<Object, Object>> getBackedProperties() {
-        return (List) properties;
+    public SchematicNode getTestblockSchematic() {
+        return testblockSchematic;
     }
 
-    public final SchematicNode getTestblockSchematic() {
-        return testblockSchematic.get();
-    }
-
-    public final void setTestblockSchematic(SchematicNode schematic) {
-        testblockSchematic.set(schematic);
-        store.save();
+    public void setTestblockSchematic(SchematicNode schematic) {
+        testblockSchematic = schematic;
+        data.setTestblockSchematic(schematic == null ? null : schematic.getId());
+        onChange.run();
     }
 
     @Override
     public final String toString() {
-        StringBuilder st = new StringBuilder();
-        st.append(getClass().getSimpleName()).append("{");
-        st.append("flagMap=").append(flagMap);
-        for (Property<?, ?> p : properties) {
-            st.append(p);
-        }
-        st.append("}");
-        return st.toString();
-    }
-
-    public final class Property<T, K> {
-        public final String field;
-        public final Function<K, T> loader;
-        public final Function<T, K> writer;
-
-        private T value;
-
-        private Property(String field, Function<K, T> loader, Function<T, K> writer) {
-            this.field = field;
-            this.loader = loader;
-            this.writer = writer;
-            properties.add(this);
-        }
-
-        public T get() {
-            return value;
-        }
-
-        public void set(T value) {
-            this.value = value;
-        }
-
-        @Override
-        public String toString() {
-            Object value = this.value;
-            if (value != null) value = writer.apply((T) value);
-            return ", " + field + "=" + value;
-        }
+        return getClass().getSimpleName() + "{" +
+                "flagMap=" + flagMap +
+                '}';
     }
 }

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

@@ -1,27 +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.region;
-
-public interface RegionDataStore {
-    void save();
-    void load(RegionData regionData);
-    default void delete() {
-    }
-}

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

@@ -35,8 +35,4 @@ public enum RegionFlagPolicy {
     public boolean isApplicable() {
         return readable || writable;
     }
-
-    public boolean notVisibleInScoreboard() {
-        return !writable;
-    }
 }

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

@@ -19,8 +19,6 @@
 
 package de.steamwar.bausystem.region;
 
-import de.steamwar.bausystem.BauSystem;
-import de.steamwar.core.Core;
 import lombok.NonNull;
 import org.bukkit.Location;
 
@@ -28,15 +26,10 @@ import javax.annotation.CheckReturnValue;
 import java.lang.reflect.InvocationTargetException;
 import java.util.Optional;
 import java.util.UUID;
-import java.util.logging.Logger;
 import java.util.stream.Stream;
 
 public interface RegionSystem {
 
-    Logger LOGGER = BauSystem.getInstance().getLogger();
-
-    UUID GLOBAL_REGION_ID = new UUID(0, 0);
-
     RegionSystem INSTANCE = init();
 
     /**
@@ -44,6 +37,11 @@ public interface RegionSystem {
      */
     void load();
 
+    /**
+     * Saves anything that should be written to file on either CRIUSleepEvent or plugin disable.
+     */
+    void save();
+
     /**
      * Returns the Location to teleport players to when they first join or Warp to "WorldSpawn"
      */
@@ -76,63 +74,47 @@ public interface RegionSystem {
     @NonNull
     Stream<Region> getRegions();
 
-    /**
-     * Only contains Regions of the same Type as the one you inputted.
-     */
-    @NonNull
-    Stream<Region> getConnectedRegions(@NonNull Region region);
-
     private static RegionSystem init() {
-        if (Core.getVersion() >= 21) {
-            // TODO: Add some kind of detection if the DynamicRegionSystem should be used!
-            try {
-                return (RegionSystem) Class.forName("de.steamwar.bausystem.region.DynamicRegionSystem").getConstructor().newInstance();
-            } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException |
-                     InvocationTargetException e) {
-                // Ignore
-            }
-        }
         try {
             return (RegionSystem) Class.forName("de.steamwar.bausystem.region.FixedRegionSystem").getConstructor().newInstance();
         } catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException |
                  InvocationTargetException e) {
-            // Ignore
+            return new RegionSystem() {
+                @Override
+                public void load() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public void save() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public @NonNull Location getWorldSpawn() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public Region getGlobalRegion() {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public Region get(Location location) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public Optional<Region> getRegion(UUID id) {
+                    throw new UnsupportedOperationException();
+                }
+
+                @Override
+                public Stream<Region> getRegions() {
+                    throw new UnsupportedOperationException();
+                }
+            };
         }
-        return new RegionSystem() {
-            @Override
-            public void load() {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public @NonNull Location getWorldSpawn() {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public Region getGlobalRegion() {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public Region get(Location location) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public Optional<Region> getRegion(UUID id) {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public Stream<Region> getRegions() {
-                throw new UnsupportedOperationException();
-            }
-
-            @Override
-            public @NonNull Stream<Region> getConnectedRegions(@NonNull Region region) {
-                throw new UnsupportedOperationException();
-            }
-        };
     }
 }

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

@@ -26,44 +26,9 @@ import lombok.RequiredArgsConstructor;
 @Getter
 public enum RegionType {
 
-    GLOBAL(ConnectionType.Water),
-    /**
-     * This should not be used by the DynamicRegionSystem
-     */
-    NORMAL(ConnectionType.Plot),
-
-    SPAWN(ConnectionType.Water),
-    SPAWN_EXTENSION(ConnectionType.Water),
-    PATH(ConnectionType.Path),
-
-    DRY(ConnectionType.Water),
-    DRY_SPECIAL(ConnectionType.Plot),
-    WET(ConnectionType.Water),
-    WET_SPECIAL(ConnectionType.Water),
+    GLOBAL(true),
+    NORMAL(false),
     ;
 
-    private final ConnectionType connectionType;
-
-    public boolean isGlobal() {
-        return this == GLOBAL;
-    }
-
-    public boolean isDeletable() {
-        return this == NORMAL || this == SPAWN_EXTENSION || this == PATH || this == DRY || this == DRY_SPECIAL || this == WET || this == WET_SPECIAL;
-    }
-
-    public boolean isSpecial() {
-        return this == DRY_SPECIAL || this == WET_SPECIAL;
-    }
-
-    public boolean isSpawn() {
-        return this == SPAWN || this == SPAWN_EXTENSION;
-    }
-
-    public enum ConnectionType {
-        Plot,
-        Path,
-        Water,
-        Garden,
-    }
+    private final boolean global;
 }

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

@@ -28,7 +28,6 @@ import org.bukkit.entity.Player;
 
 import java.util.function.Consumer;
 import java.util.function.Function;
-import java.util.stream.Stream;
 
 @UtilityClass
 public class RegionUtils {
@@ -59,12 +58,10 @@ public class RegionUtils {
     }
 
     public void forEachInRegion(Region region, Consumer<Player> consumer) {
-        Stream<? extends Player> players = Bukkit.getOnlinePlayers().stream();
-        if (region.getType().isGlobal()) {
-            players = players.filter(player -> Region.getRegion(player.getLocation()).getType().isGlobal());
-        } else {
-            players = players.filter(player -> region.getArea().inRegion(player.getLocation(), false));
-        }
-        players.forEach(consumer);
+        Bukkit.getOnlinePlayers()
+                .stream()
+                .filter(player -> region.getArea().inRegion(player.getLocation(), false))
+                .filter(player -> !region.getType().isGlobal() || Region.getRegion(player.getLocation()).getType().isGlobal())
+                .forEach(consumer);
     }
 }

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

@@ -42,7 +42,7 @@ import java.util.function.BiPredicate;
 @Getter
 public class PasteBuilder {
 
-    private ClipboardProvider clipboardProvider;
+    private final ClipboardProvider clipboardProvider;
     private Point pastPoint;
     private boolean rotate;
     private boolean ignoreAir;
@@ -53,20 +53,10 @@ public class PasteBuilder {
     private List<BiPredicate<BaseBlock, String>> predicates = new ArrayList<>();
     private List<BiConsumer<Clipboard, BlockVector3>> mappers = new ArrayList<>();
 
-    public PasteBuilder() {
-        clipboardProvider = ClipboardProvider.EMPTY;
-    }
-
     public PasteBuilder(@NonNull ClipboardProvider clipboardProvider) {
         this.clipboardProvider = clipboardProvider;
     }
 
-    public PasteBuilder with(@NonNull ClipboardProvider clipboardProvider) {
-        if (this.clipboardProvider != ClipboardProvider.EMPTY) return this;
-        this.clipboardProvider = clipboardProvider;
-        return this;
-    }
-
     public PasteBuilder pastePoint(Point point) {
         this.pastPoint = point;
         return this;
@@ -102,16 +92,6 @@ public class PasteBuilder {
         return this;
     }
 
-    private PasteBuilder predicates(List<BiPredicate<BaseBlock, String>> predicates) {
-        this.predicates = predicates;
-        return this;
-    }
-
-    public PasteBuilder mappers(List<BiConsumer<Clipboard, BlockVector3>> mappers) {
-        this.mappers = mappers;
-        return this;
-    }
-
     public PasteBuilder only(BiPredicate<BaseBlock, String> predicate) {
         predicates.add(predicate);
         return this;
@@ -202,27 +182,13 @@ public class PasteBuilder {
     }
 
     public EditSession run() {
-        if (pastPoint != null || minPoint != null) {
-            return FlatteningWrapper.impl.paste(this);
+        if (pastPoint == null) {
+            throw new IllegalStateException("pastePoint is null");
         }
-        throw new IllegalStateException("pastePoint is null");
+        return FlatteningWrapper.impl.paste(this);
     }
 
     public interface ClipboardProvider {
-        ClipboardProvider EMPTY = new EmptyProvider();
-
-        static ClipboardProvider file(File file) {
-            return new FileProvider(file);
-        }
-
-        static ClipboardProvider schematic(SchematicNode schematic) {
-            return new SchematicProvider(schematic);
-        }
-
-        static ClipboardProvider clipboard(Clipboard clipboard) {
-            return new ClipboardProviderImpl(clipboard);
-        }
-
         Clipboard getClipboard();
 
         default <T extends ClipboardProvider> boolean is(Class<T> clazz) {
@@ -234,22 +200,12 @@ public class PasteBuilder {
         }
     }
 
-    private static class EmptyProvider implements ClipboardProvider {
-        private EmptyProvider() {
-        }
-
-        @Override
-        public Clipboard getClipboard() {
-            return null;
-        }
-    }
-
     @Getter
     public static class FileProvider implements ClipboardProvider {
         private final File file;
         private final Clipboard clipboard;
 
-        private FileProvider(File file) {
+        public FileProvider(File file) {
             this.file = file;
             this.clipboard = FlatteningWrapper.impl.loadSchematic(file);
         }
@@ -265,7 +221,7 @@ public class PasteBuilder {
         private final SchematicNode schematic;
         private final Clipboard clipboard;
 
-        private SchematicProvider(SchematicNode schematic) {
+        public SchematicProvider(SchematicNode schematic) {
             this.schematic = schematic;
             try {
                 this.clipboard = new SchematicData(schematic).load();
@@ -284,7 +240,7 @@ public class PasteBuilder {
     public static class ClipboardProviderImpl implements ClipboardProvider {
         private final Clipboard clipboard;
 
-        private ClipboardProviderImpl(Clipboard clipboard) {
+        public ClipboardProviderImpl(Clipboard clipboard) {
             this.clipboard = clipboard;
         }
 

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");
-    }
-}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/worlddata/WorldData.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,58 +19,83 @@
 
 package de.steamwar.bausystem.worlddata;
 
-import lombok.experimental.UtilityClass;
+import com.google.gson.GsonBuilder;
+import de.steamwar.bausystem.config.ConfigStore;
+import de.steamwar.bausystem.config.VersionedConfig;
+import de.steamwar.bausystem.worlddata.converter.WorldDataV1ToV2Converter;
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.Setter;
 import org.bukkit.Bukkit;
-import yapion.hierarchy.output.FileOutput;
-import yapion.hierarchy.types.YAPIONObject;
-import yapion.parser.InputStreamCharsets;
-import yapion.parser.YAPIONParser;
-import yapion.parser.options.StreamOptions;
 
-import java.io.BufferedInputStream;
 import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
 
-@UtilityClass
-public class WorldData {
+/**
+ * The current world data. 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 WorldDataV{@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 WorldData implements VersionedConfig {
 
-    private final File optionsFile = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "options.yapion");
-    private YAPIONObject worldData;
+    public static final int VERSION = 2;
 
-    public YAPIONObject getWorldData() {
-        if (worldData == null) {
-            read();
-        }
-        return worldData;
+    public static final ConfigStore<WorldData> STORE = new ConfigStore<>(WorldData.class, VERSION, WorldData::new)
+            .gson(new GsonBuilder().setPrettyPrinting().create())
+            .converter(new WorldDataV1ToV2Converter())
+            .file(new File(Bukkit.getWorlds().get(0).getWorldFolder(), "options.json"))
+            .legacyFile(new File(Bukkit.getWorlds().get(0).getWorldFolder(), "options.yapion"), WorldDataV1::parse);
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Region name to the data of the region
+     */
+    protected Map<String, RegionEntry> regions = new HashMap<>();
+    protected RegionEntry globalRegion = new RegionEntry();
+
+    /**
+     * Warp name to warp
+     */
+    protected Map<String, WarpEntry> warps = new HashMap<>();
+
+    @Getter
+    @Setter
+    public static class RegionEntry {
+
+        /**
+         * Overrides the prototype of the region config, null if not overridden
+         */
+        protected String prototype = null;
+
+        /**
+         * Flag name to flag value name
+         */
+        protected Map<String, String> flags = new HashMap<>();
+
+        /**
+         * Id of the testblock SchematicNode, null if the default testblock is used
+         */
+        protected Integer testblockSchematic = null;
     }
 
-    public YAPIONObject getRegionsData() {
-        return getWorldData().getYAPIONObjectOrSetDefault("regions", new YAPIONObject());
-    }
+    @Getter
+    @Setter
+    public static class WarpEntry {
 
-    public YAPIONObject getWarpData() {
-        return getWorldData().getYAPIONObjectOrSetDefault("warps", new YAPIONObject());
-    }
-
-    private void read() {
-        worldData = new YAPIONObject();
-        if (optionsFile.length() != 0) {
-            try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(optionsFile))) {
-                worldData = YAPIONParser.parse(bufferedInputStream, new StreamOptions().charset(InputStreamCharsets.UTF_8));
-            } catch (IOException e) {
-                // Ignored
-            }
-        } else {
-            write();
-        }
-    }
-
-    public void write() {
-        try {
-            worldData.toYAPION(new FileOutput(optionsFile)).close();
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
+        protected double x;
+        protected double y;
+        protected double z;
+        protected float yaw;
+        protected float pitch;
+        protected String material;
     }
 }

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

@@ -0,0 +1,111 @@
+/*
+ *   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.worlddata;
+
+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.Map;
+
+/**
+ * The legacy world data that was stored in the YAPION format in options.yapion.
+ */
+@Getter
+@Setter
+@Deprecated
+public class WorldDataV1 implements VersionedConfig {
+
+    public static final int VERSION = 1;
+
+    @Setter(AccessLevel.NONE)
+    protected int version = VERSION;
+
+    /**
+     * Region name to the data of the region, the global region is stored with the name "global"
+     */
+    protected Map<String, RegionEntry> regions = new HashMap<>();
+
+    /**
+     * Warp name to warp
+     */
+    protected Map<String, WarpEntry> warps = new HashMap<>();
+
+    @Getter
+    @Setter
+    public static class RegionEntry {
+
+        protected String prototype = null;
+
+        /**
+         * Flag name to flag value name and "testblockSchematic" to the SchematicNode id
+         */
+        protected Map<String, Object> flagStorage = new HashMap<>();
+    }
+
+    @Getter
+    @Setter
+    public static class WarpEntry {
+
+        protected double x;
+        protected double y;
+        protected double z;
+        protected float yaw;
+        protected float pitch;
+        protected String material;
+    }
+
+    public static WorldDataV1 parse(String yapion) {
+        Map<String, Object> object = YapionReader.parse(yapion);
+        WorldDataV1 worldData = new WorldDataV1();
+
+        if (object.get("regions") instanceof Map<?, ?> regions) {
+            regions.forEach((name, value) -> {
+                if (!(value instanceof Map<?, ?> region)) return;
+                RegionEntry entry = new RegionEntry();
+                if (region.get("prototype") instanceof String prototype) {
+                    entry.prototype = prototype;
+                }
+                if (region.get("flagStorage") instanceof Map<?, ?> flagStorage) {
+                    flagStorage.forEach((key, flag) -> entry.flagStorage.put((String) key, flag));
+                }
+                worldData.regions.put((String) name, entry);
+            });
+        }
+
+        if (object.get("warps") instanceof Map<?, ?> warps) {
+            warps.forEach((name, value) -> {
+                if (!(value instanceof Map<?, ?> warp)) return;
+                WarpEntry entry = new WarpEntry();
+                entry.x = ((Number) warp.get("x")).doubleValue();
+                entry.y = ((Number) warp.get("y")).doubleValue();
+                entry.z = ((Number) warp.get("z")).doubleValue();
+                entry.yaw = ((Number) warp.get("yaw")).floatValue();
+                entry.pitch = ((Number) warp.get("pitch")).floatValue();
+                entry.material = (String) warp.get("material");
+                worldData.warps.put((String) name, entry);
+            });
+        }
+        return worldData;
+    }
+}

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/worlddata/converter/WorldDataV1ToV2Converter.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.worlddata.converter;
+
+import de.steamwar.bausystem.config.ConfigConverter;
+import de.steamwar.bausystem.worlddata.WorldData;
+import de.steamwar.bausystem.worlddata.WorldDataV1;
+
+@Deprecated
+public class WorldDataV1ToV2Converter implements ConfigConverter<WorldDataV1, WorldData> {
+
+    private static final String GLOBAL_REGION = "global";
+    private static final String TESTBLOCK_SCHEMATIC = "testblockSchematic";
+
+    @Override
+    public int version() {
+        return WorldDataV1.VERSION;
+    }
+
+    @Override
+    public WorldData convert(WorldDataV1 old) {
+        WorldData worldData = new WorldData();
+        old.getRegions().forEach((name, region) -> {
+            if (name.equals(GLOBAL_REGION)) {
+                worldData.setGlobalRegion(convert(region));
+            } else {
+                worldData.getRegions().put(name, convert(region));
+            }
+        });
+        old.getWarps().forEach((name, warp) -> worldData.getWarps().put(name, convert(warp)));
+        return worldData;
+    }
+
+    private WorldData.RegionEntry convert(WorldDataV1.RegionEntry old) {
+        WorldData.RegionEntry region = new WorldData.RegionEntry();
+        region.setPrototype(old.getPrototype());
+        old.getFlagStorage().forEach((key, value) -> {
+            if (value == null) return;
+            if (key.equals(TESTBLOCK_SCHEMATIC)) {
+                region.setTestblockSchematic(((Number) value).intValue());
+            } else {
+                region.getFlags().put(key, value.toString());
+            }
+        });
+        return region;
+    }
+
+    private WorldData.WarpEntry convert(WorldDataV1.WarpEntry old) {
+        WorldData.WarpEntry warp = new WorldData.WarpEntry();
+        warp.setX(old.getX());
+        warp.setY(old.getY());
+        warp.setZ(old.getZ());
+        warp.setYaw(old.getYaw());
+        warp.setPitch(old.getPitch());
+        warp.setMaterial(old.getMaterial());
+        return warp;
+    }
+}

BauSystem/BauSystem_RegionDynamic/build.gradle.kts

@@ -1,44 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2024  SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-plugins {
-    steamwar.java
-}
-
-tasks.compileJava {
-    options.isWarnings = false
-}
-
-dependencies {
-    compileOnly(libs.classindex)
-    annotationProcessor(libs.classindex)
-
-    compileOnly(project(":BauSystem:BauSystem_Main", "default"))
-    compileOnly(project(":SpigotCore", "default"))
-
-    compileOnly(libs.paperapi)
-    compileOnly(libs.axiom)
-    compileOnly(libs.authlib)
-    compileOnly(libs.viaapi)
-
-    compileOnly(libs.nms)
-    compileOnly(libs.fawe)
-
-    implementation(libs.luaj)
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/features/region/WireframeCommand.java

@@ -1,77 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.features.region;
-
-import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.region.Point;
-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.TestblockMode;
-import de.steamwar.bausystem.utils.PasteBuilder;
-import de.steamwar.command.SWCommand;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-import java.util.logging.Level;
-
-public class WireframeCommand extends SWCommand {
-
-    public WireframeCommand() {
-        super("wireframe");
-    }
-
-    @Register(description = "REGION_WIREFRAME_HELP_RESET")
-    public void wireframeCommand(@Validator Player p) {
-        Region region = regionCheck(p);
-        if (region == null) return;
-
-        try {
-            PasteBuilder pasteBuilder = new PasteBuilder()
-                    .ignoreAir(true)
-                    .color(region.getRegionData().get(Flag.COLOR).getWithDefault());
-            region.getBuildArea().reset(pasteBuilder, false);
-            RegionUtils.message(region, "REGION_WIREFRAME_DONE");
-        } catch (SecurityException e) {
-            BauSystem.MESSAGE.send("REGION_WIREFRAME_ERROR", p);
-            Bukkit.getLogger().log(Level.WARNING, "Failed wireframe", e);
-        }
-    }
-
-    private Region regionCheck(Player player) {
-        Region region = Region.getRegion(player.getLocation());
-        if (region.getRegionData().has(Flag.TESTBLOCK).isWritable() && region.getRegionData().get(Flag.TESTBLOCK).isWithDefault(TestblockMode.NO_VALUE)) {
-            Point minPoint = region.getArea().getMinPoint(false);
-            Point maxPoint = region.getArea().getMaxPoint(false);
-            // TODO: Check if empty!
-            int half = minPoint.getZ() + (maxPoint.getZ() - minPoint.getZ()) / 2;
-            if (player.getLocation().getBlockZ() <= half) {
-                region.getRegionData().set(Flag.TESTBLOCK, TestblockMode.SOUTH);
-            } else {
-                region.getRegionData().set(Flag.TESTBLOCK, TestblockMode.NORTH);
-            }
-        }
-        if (region.getTestblockArea().isEmpty()) {
-            BauSystem.MESSAGE.send("REGION_WIREFRAME_NO_REGION", player);
-            return null;
-        }
-        return region;
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/00000000-0000-0000-0000-000000000000/flags.json

@@ -1,9 +0,0 @@
-{
-  "flags": {
-    "TNT": "DENY",
-    "FREEZE": "INACTIVE"
-  },
-  "properties": {
-    "testblockSchematic": 0
-  }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/00000000-0000-0000-0000-000000000000/meta.json

@@ -1,9 +0,0 @@
-{
-  "region_identifier": "SpawnRegion",
-  "tiles": [
-    {
-      "tile_x": 0,
-      "tile_z": 0
-    }
-  ]
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/DynamicRegionCommand.java

@@ -1,59 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  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;
-
-import de.steamwar.bausystem.Permission;
-import de.steamwar.bausystem.features.region.RegionCommand;
-import de.steamwar.command.AbstractSWCommand;
-import de.steamwar.command.SWCommand;
-import de.steamwar.core.SWPlayer;
-import org.bukkit.entity.Player;
-
-@AbstractSWCommand.PartOf(RegionCommand.class)
-public class DynamicRegionCommand extends SWCommand {
-
-    public DynamicRegionCommand() {
-        super("");
-    }
-
-    @Register({"dynamic"})
-    public void visualizeRegions(Player player) {
-        SWPlayer swPlayer = SWPlayer.of(player);
-        if (swPlayer.hasComponent(DynamicRegionVisualizer2.class)) {
-            swPlayer.removeComponent(DynamicRegionVisualizer2.class);
-            swPlayer.removeComponent(DynamicRegionEditor2.class);
-        } else {
-            swPlayer.setComponent(DynamicRegionVisualizer2.INSTANCE);
-            if (Permission.SUPERVISOR.hasPermission(player)) {
-                swPlayer.setComponent(new DynamicRegionEditor2());
-            }
-        }
-        if (true) return;
-        if (swPlayer.hasComponent(DynamicRegionVisualizer.class)) {
-            swPlayer.removeComponent(DynamicRegionVisualizer.class);
-            swPlayer.removeComponent(DynamicRegionEditor.class);
-        } else {
-            swPlayer.setComponent(DynamicRegionVisualizer.INSTANCE);
-            if (Permission.SUPERVISOR.hasPermission(player)) {
-                swPlayer.setComponent(new DynamicRegionEditor(player.getPlayer()));
-            }
-        }
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/DynamicRegionEditor.java

@@ -1,525 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.region;
-
-import com.comphenix.tinyprotocol.TinyProtocol;
-import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.Permission;
-import de.steamwar.bausystem.region.dynamic.DynamicRegion;
-import de.steamwar.bausystem.region.dynamic.DynamicRegionRepository;
-import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
-import de.steamwar.bausystem.region.dynamic.Tile;
-import de.steamwar.bausystem.region.dynamic.spawn.SpawnRegion;
-import de.steamwar.bausystem.utils.PasteBuilder;
-import de.steamwar.core.SWPlayer;
-import de.steamwar.entity.CArea;
-import de.steamwar.entity.REntityServer;
-import de.steamwar.entity.RInteraction;
-import de.steamwar.inventory.SWInventory;
-import de.steamwar.inventory.SWItem;
-import de.steamwar.inventory.SWListInv;
-import lombok.NonNull;
-import net.md_5.bungee.api.ChatMessageType;
-import net.md_5.bungee.api.chat.TextComponent;
-import net.minecraft.network.protocol.game.ServerboundMovePlayerPacket;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.event.player.PlayerSwapHandItemsEvent;
-import org.bukkit.scheduler.BukkitTask;
-import org.bukkit.util.Vector;
-import org.joml.RayAabIntersection;
-
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
-import java.util.function.BiFunction;
-
-public class DynamicRegionEditor implements SWPlayer.Component, Listener {
-
-    static {
-        BiFunction<Player, Object, Object> function = (player, object) -> {
-            SWPlayer.of(player).getComponent(DynamicRegionEditor.class).ifPresent(DynamicRegionEditor::calcCursor);
-            return object;
-        };
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Pos.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.Rot.class, function);
-        TinyProtocol.instance.addFilter(ServerboundMovePlayerPacket.PosRot.class, function);
-    }
-
-    private final REntityServer entityServer = new REntityServer();
-    private final CArea area = new CArea(entityServer);
-
-    private static final BlockData DELETE = Material.RED_CONCRETE.createBlockData();
-    private static final BlockData INVALID = Material.YELLOW_CONCRETE.createBlockData();
-    private static final BlockData PLACE = Material.LIME_CONCRETE.createBlockData();
-
-    {
-        area.hide(true);
-    }
-
-    private final Player player;
-
-    private final BukkitTask task;
-    private Type type = new Empty();
-
-    public DynamicRegionEditor(Player player) {
-        this.player = player;
-        entityServer.addPlayer(player);
-
-        Bukkit.getPluginManager().registerEvents(this, BauSystem.getInstance());
-
-        for (int i = 0; i < 121; i++) {
-            new RInteraction(entityServer, player.getLocation());
-        }
-        moveInteractionEntities(Point.fromLocation(player.getLocation()));
-
-        CArea area = new CArea(entityServer);
-        area.setPos1And2(new Location(null, -Tile.maxTile, 51, -Tile.maxTile), new Location(null, Tile.maxTile, 51, Tile.maxTile));
-        area.setBlock(Material.BEDROCK.createBlockData());
-
-        task = Bukkit.getScheduler().runTaskTimer(BauSystem.getInstance(), this::showHotbar, 0, 20);
-    }
-
-    private void showHotbar() {
-        entityServer.tick();
-
-        StringBuilder st = new StringBuilder();
-        st.append(type.title());
-        st.append(" §8(§7Change with §eSwap Hands§8)");
-        player.spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(st.toString()));
-    }
-
-    @Override
-    public void onUnmount(SWPlayer player) {
-        entityServer.close();
-        task.cancel();
-        PlayerMoveEvent.getHandlerList().unregister(this);
-        PlayerSwapHandItemsEvent.getHandlerList().unregister(this);
-        PlayerInteractEvent.getHandlerList().unregister(this);
-    }
-
-    @EventHandler
-    public void onPlayerMove(PlayerMoveEvent event) {
-        if (event.getPlayer() != player) return;
-        if (!Permission.SUPERVISOR.hasPermission(player)) {
-            SWPlayer.of(player).removeComponent(DynamicRegionEditor.class);
-            return;
-        }
-        if (event.getTo() == null) return;
-        if (event.getFrom().getBlockX() == event.getTo().getBlockX() && event.getFrom().getBlockZ() == event.getTo().getBlockZ()) {
-            return;
-        }
-        moveInteractionEntities(Point.fromLocation(event.getTo()));
-    }
-
-    private void moveInteractionEntities(Point position) {
-        List<RInteraction> interactionList = entityServer.getEntitiesByType(RInteraction.class);
-        for (int x = -5; x <= 5; x++) {
-            for (int z = -5; z <= 5; z++) {
-                interactionList.removeFirst().move(position.getX() + x + 0.5, 50, position.getZ() + z + 0.5, 0, 0, (byte) 0);
-            }
-        }
-    }
-
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onPlayerSwapHandItems(PlayerSwapHandItemsEvent event) {
-        if (event.getPlayer() != player) return;
-        event.setCancelled(true);
-
-        List<SWListInv.SWListEntry<Type>> list = new ArrayList<>();
-        list.add(new SWListInv.SWListEntry<>(new SWItem(Material.STRUCTURE_VOID, "§6Deselect"), new Empty()));
-        list.add(new SWListInv.SWListEntry<>(new SWItem(Material.BARRIER, "§cDelete"), new Delete(false)));
-        list.add(new SWListInv.SWListEntry<>(new SWItem(Material.COMMAND_BLOCK, "§4§lForce Delete", List.of("§7Force deletes enables §cdeleting", "§7of §6Special§7 regions without", "§7confirmation§8."), false, null), new Delete(true)));
-        list.add(new SWListInv.SWListEntry<>(new SWItem(Material.LODESTONE, "§fBig Spawn"), new Spawn()));
-
-        DynamicRegionSystem.constructorDataMap.values()
-                .stream()
-                .filter(RegionConstructorData::placeable)
-                .sorted(Comparator.comparing(RegionConstructorData::name))
-                .forEach(data -> {
-                    list.add(new SWListInv.SWListEntry<>(new SWItem(data.material(), "§f" + data.name()), new Place(data)));
-                });
-
-        SWListInv<Type> inventory = new SWListInv<>(player, "Select Region to place", list, (click, type) -> {
-            if (type instanceof Delete delete) {
-                delete.confirmForceDelete(player, () -> {
-                    player.closeInventory();
-                    this.type = delete;
-                    area.hide(true);
-                    showHotbar();
-                });
-            } else {
-                player.closeInventory();
-                this.type = type;
-                area.hide(true);
-                showHotbar();
-            }
-        });
-        inventory.open();
-    }
-
-    private void calcCursor() {
-        Location startPos = player.getLocation().clone().add(0.0, player.getEyeHeight(), 0.0);
-        Vector direction = player.getLocation().getDirection();
-
-        RayAabIntersection intersection = new RayAabIntersection((float) startPos.getX(), (float) startPos.getY(), (float) startPos.getZ(), (float) direction.getX(), (float) direction.getY(), (float) direction.getZ());
-        for (RInteraction interaction : entityServer.getEntitiesByType(RInteraction.class)) {
-            float x = (float) (interaction.getX() - 0.5);
-            float z = (float) (interaction.getZ() - 0.5);
-            if (intersection.test(x, (float) 50.95, z, x + 1, (float) 51.05, z + 1)) {
-                int tileX = (int) x;
-                int tileZ = (int) z;
-                if (type.visualize(area, tileX, tileZ)) {
-                    area.hide(false);
-                    return;
-                } else {
-                    break;
-                }
-            }
-        }
-        area.hide(true);
-    }
-
-    @EventHandler
-    public void onPlayerInteract(PlayerInteractEvent event) {
-        if (event.getPlayer() != player) return;
-        Location startPos = player.getLocation().clone().add(0.0, player.getEyeHeight(), 0.0);
-        Vector direction = player.getLocation().getDirection();
-        if (direction.getY() > 0) return;
-
-        RayAabIntersection intersection = new RayAabIntersection((float) startPos.getX(), (float) startPos.getY(), (float) startPos.getZ(), (float) direction.getX(), (float) direction.getY(), (float) direction.getZ());
-        for (RInteraction interaction : entityServer.getEntitiesByType(RInteraction.class)) {
-            float x = (float) (interaction.getX() - 0.5);
-            float z = (float) (interaction.getZ() - 0.5);
-            if (intersection.test(x, (float) 50.95, z, x + 1, (float) 51.05, z + 1)) {
-                int tileX = (int) x;
-                int tileZ = (int) z;
-                type.run(event.getPlayer(), tileX, tileZ);
-                break;
-            }
-        }
-    }
-
-    private interface Type {
-
-        String title();
-
-        boolean visualize(CArea area, int tileX, int tileZ);
-
-        void run(Player player, int tileX, int tileZ);
-    }
-
-    private static class Empty implements Type {
-
-        private Empty() {
-        }
-
-        @Override
-        public String title() {
-            return "§6---";
-        }
-
-        @Override
-        public boolean visualize(CArea area, int tileX, int tileZ) {
-            return false;
-        }
-
-        @Override
-        public void run(Player player, int tileX, int tileZ) {
-        }
-    }
-
-    private static class Delete implements Type {
-
-        protected static final String CONFIRM_DELETE = "Confirm delete: ";
-        protected static final String ACCEPT_DELETE = "§cDelete: ";
-
-        private final boolean force;
-        private boolean valid = false;
-
-        private Delete(boolean force) {
-            this.force = force;
-        }
-
-        public void confirmForceDelete(Player player, Runnable callback) {
-            if (force) {
-                confirmInventory(player, "Enable Force Delete", "§cEnable", "", callback);
-            } else {
-                callback.run();
-            }
-        }
-
-        @Override
-        public String title() {
-            if (force) {
-                return "§4§lForce Delete";
-            } else {
-                return "§cDelete";
-            }
-        }
-
-        private boolean isBigSpawn() {
-            if (!DynamicRegionSystem.INSTANCE.get(Tile.ZERO).getType().isSpawn()) return false;
-            return Tile.ZERO.neighboursRing()
-                    .map(DynamicRegionSystem.INSTANCE::get)
-                    .map(Region::getType)
-                    .allMatch(RegionType::isSpawn);
-        }
-
-        @Override
-        public boolean visualize(CArea area, int tileX, int tileZ) {
-            // TODO: Special case for big Spawn!
-
-            Tile tile = Tile.fromTile(tileX, tileZ).orElse(null);
-            if (tile == null) {
-                valid = false;
-                return false;
-            }
-            Region region = DynamicRegionSystem.INSTANCE.get(tile);
-            if (region.getType().isGlobal()) {
-                valid = false;
-                return false;
-            }
-
-            if (region.getType().isSpawn()) {
-                if (!isBigSpawn()) {
-                    valid = false;
-                    return false;
-                }
-                return selectSpawn(area);
-            } else {
-                return selectRegion(area, region);
-            }
-        }
-
-        private boolean selectSpawn(CArea area) {
-            Location minLoc = new Location(null, -1, 51, -1);
-            Location maxLoc = new Location(null, 1, 51, 1);
-            area.setBlock(DELETE);
-            area.setPos1And2(minLoc, maxLoc);
-            valid = true;
-            return true;
-        }
-
-        private boolean selectRegion(CArea area, Region region) {
-            Tile minTile = Tile.fromPoint(region.getArea().getMinPoint(false)).orElse(null);
-            Tile maxTile = Tile.fromPoint(region.getArea().getMaxPoint(false)).orElse(null);
-            if (minTile == null || maxTile == null) {
-                valid = false;
-                return false;
-            }
-            Location minLoc = new Location(null, minTile.getTileX(), 51, minTile.getTileZ());
-            Location maxLoc = new Location(null, maxTile.getTileX(), 51, maxTile.getTileZ());
-            area.setBlock(DELETE);
-            area.setPos1And2(minLoc, maxLoc);
-            valid = true;
-            return true;
-        }
-
-        @Override
-        public void run(Player player, int tileX, int tileZ) {
-            if (!valid) return;
-            Tile tile = Tile.fromTile(tileX, tileZ).orElse(null);
-            if (tile == null) return;
-            Region region = DynamicRegionSystem.INSTANCE.get(tile);
-            if (region.getType().isGlobal()) return;
-
-            if (region.getType().isSpawn()) {
-                if (isBigSpawn()) deleteSpawn(player);
-                return;
-            }
-
-            if (region.getType() == RegionType.PATH || (force && region.getType().isSpecial())) {
-                region.delete();
-            } else {
-                deleteRegion(player, tile, region);
-            }
-        }
-
-        private void deleteSpawn(Player player) {
-            confirmInventory(player, CONFIRM_DELETE, ACCEPT_DELETE, "Big Spawn", () -> {
-                checkSpawnRegionAndDelete(Tile.TILE_NN);
-                checkSpawnRegionAndDelete(Tile.TILE_NP);
-                checkSpawnRegionAndDelete(Tile.TILE_PN);
-                checkSpawnRegionAndDelete(Tile.TILE_PP);
-
-                DynamicRegionSystem.INSTANCE.get(Tile.ZERO).getArea().place(new PasteBuilder(), false);
-                DynamicRegionSystem.INSTANCE.get(Tile.TILE_NZ).getArea().place(new PasteBuilder(), false);
-                DynamicRegionSystem.INSTANCE.get(Tile.TILE_PZ).getArea().place(new PasteBuilder(), false);
-                DynamicRegionSystem.INSTANCE.get(Tile.TILE_ZN).getArea().place(new PasteBuilder(), false);
-                DynamicRegionSystem.INSTANCE.get(Tile.TILE_ZP).getArea().place(new PasteBuilder(), false);
-            });
-        }
-
-        private void checkSpawnRegionAndDelete(Tile tile) {
-            Region region = DynamicRegionSystem.INSTANCE.get(tile);
-            if (region.getType().isSpawn()) region.delete();
-        }
-
-        private void deleteRegion(Player player, Tile tile, Region region) {
-            RegionConstructorData data = DynamicRegionSystem.constructorDataMap.get(region.getClass());
-            confirmInventory(player, CONFIRM_DELETE, ACCEPT_DELETE, data.name(), () -> {
-                Region checkRegion = DynamicRegionSystem.INSTANCE.get(tile);
-                if (region == checkRegion) region.delete();
-            });
-        }
-
-        private void confirmInventory(Player player, String title, String accept, String name, Runnable deleteCallback) {
-            SWInventory inventory = new SWInventory(player, 9, title + name);
-            inventory.setItem(0, new SWItem(Material.GRAY_CONCRETE, "§7Cancel", click -> {
-                player.closeInventory();
-            }));
-            inventory.setItem(8, new SWItem(Material.RED_CONCRETE, accept + name, click -> {
-                player.closeInventory();
-                deleteCallback.run();
-            }));
-            inventory.open();
-        }
-    }
-
-    private static class Spawn extends Place {
-
-        private Spawn() {
-            super(3, 3);
-        }
-
-        @Override
-        public String title() {
-            return "§ePlace§8: §aBig Spawn";
-        }
-
-        @Override
-        public boolean validPlacement(int tileX, int tileZ) {
-            if (tileX != -1 || tileZ != -1) return false;
-            if (!DynamicRegionSystem.INSTANCE.get(Tile.TILE_NN).getType().isGlobal()) return false;
-            if (!DynamicRegionSystem.INSTANCE.get(Tile.TILE_NP).getType().isGlobal()) return false;
-            if (!DynamicRegionSystem.INSTANCE.get(Tile.TILE_PN).getType().isGlobal()) return false;
-            if (!DynamicRegionSystem.INSTANCE.get(Tile.TILE_PP).getType().isGlobal()) return false;
-            return true;
-        }
-
-        @Override
-        public void run(Player player, int tileX, int tileZ) {
-            if (!valid) return;
-            // Center Tile placement!
-            tileX -= widthX / 2;
-            tileZ -= widthZ / 2;
-            if (!validPlacement(tileX, tileZ)) return;
-
-            constructSpawnRegion(Tile.TILE_NN);
-            constructSpawnRegion(Tile.TILE_NP);
-            constructSpawnRegion(Tile.TILE_PN);
-            DynamicRegion region = constructSpawnRegion(Tile.TILE_PP);
-            if (region != null) region.getArea().reset(new PasteBuilder(), false);
-        }
-
-        private DynamicRegion constructSpawnRegion(Tile tile) {
-            DynamicRegion region = DynamicRegionRepository.constructRegion(SpawnRegion.class, tile);
-            if (region == null) return null;
-            region.updateNeighbours();
-            return region;
-        }
-    }
-
-    private static class Place implements Type {
-
-        private final RegionConstructorData data;
-        protected final int widthX;
-        protected final int widthZ;
-
-        protected boolean valid = false;
-
-        private Place(@NonNull RegionConstructorData data) {
-            this(data, data.widthX(), data.widthZ());
-        }
-
-        private Place(int widthX, int widthZ) {
-            this(null, widthX, widthZ);
-        }
-
-        private Place(RegionConstructorData data, int widthX, int widthZ) {
-            this.data = data;
-            this.widthX = widthX - 1;
-            this.widthZ = widthZ - 1;
-        }
-
-        @Override
-        public String title() {
-            return "§ePlace§8: §a" + data.name();
-        }
-
-        public boolean validPlacement(int tileX, int tileZ) {
-            for (int x = 0; x <= widthX; x++) {
-                for (int z = 0; z <= widthZ; z++) {
-                    Tile tile = Tile.fromTile(tileX + x, tileZ + z).orElse(null);
-                    if (tile == null) return false;
-                    Region region = DynamicRegionSystem.INSTANCE.get(tile);
-                    if (!region.getType().isGlobal()) return false;
-                }
-            }
-            return true;
-        }
-
-        @Override
-        public boolean visualize(CArea area, int tileX, int tileZ) {
-            Tile tile = Tile.fromTile(tileX, tileZ).orElse(null);
-            if (tile == null) {
-                valid = false;
-                return false;
-            }
-            // Center Tile placement!
-            tileX -= widthX / 2;
-            tileZ -= widthZ / 2;
-            // Validate placements!
-            if (validPlacement(tileX, tileZ)) {
-                area.setBlock(PLACE);
-                valid = true;
-            } else {
-                area.setBlock(INVALID);
-                valid = false;
-            }
-            area.setPos1And2(new Location(null, tileX, 51, tileZ), new Location(null, tileX + widthX, 51, tileZ + widthZ));
-            return true;
-        }
-
-        @Override
-        public void run(Player player, int tileX, int tileZ) {
-            if (!valid) return;
-            // Center Tile placement!
-            tileX -= widthX / 2;
-            tileZ -= widthZ / 2;
-            if (!validPlacement(tileX, tileZ)) return;
-            Tile tile = Tile.fromTile(tileX, tileZ).orElse(null);
-            if (tile == null) return;
-            DynamicRegion region = DynamicRegionRepository.constructRegion(DynamicRegionSystem.identifierDataMap.get(data.identifier()), tile);
-            if (region == null) return;
-            region.getArea().place(new PasteBuilder(), false);
-            region.updateNeighbours();
-        }
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/DynamicRegionSystem.java

@@ -1,250 +0,0 @@
-/*
- * This file is a part of the SteamWar software.
- *
- * Copyright (C) 2020  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;
-
-import de.steamwar.bausystem.BauSystem;
-import de.steamwar.bausystem.features.region.WireframeCommand;
-import de.steamwar.bausystem.region.dynamic.*;
-import de.steamwar.bausystem.region.dynamic.global.GlobalRegion;
-import lombok.NonNull;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.jetbrains.annotations.NotNull;
-
-import javax.annotation.Nullable;
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.util.*;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-public class DynamicRegionSystem implements RegionSystem {
-
-    public static DynamicRegionSystem INSTANCE;
-
-    private static final Map<Long, Region> regionCache = new LinkedHashMap<>(16, 0.75f, true) {
-        @Override
-        protected boolean removeEldestEntry(Map.Entry<Long, Region> eldest) {
-            return size() > 8192; // Tweak this number if needed!
-        }
-    }; // Will be cleared on region add/delete/remove!
-    private static final Map<UUID, Region> regionMap = new HashMap<>();
-    private static final Map<RegionType, Set<Region>> regionTypeMap = new EnumMap<>(RegionType.class);
-
-    public void add(DynamicRegion region) {
-        regionCache.clear();
-        regionMap.put(region.getID(), region);
-        regionTypeMap.computeIfAbsent(region.getType(), __ -> new HashSet<>()).add(region);
-        DynamicRegionVisualizer.INSTANCE.addRegion(region);
-    }
-
-    public void remove(DynamicRegion region) {
-        regionCache.clear();
-        regionMap.remove(region.getID());
-        regionTypeMap.getOrDefault(region.getType(), Collections.emptySet()).remove(region);
-        DynamicRegionVisualizer.INSTANCE.removeRegion(region);
-    }
-
-    public static Map<Class<? extends DynamicRegion>, RegionConstructorData> constructorDataMap = new HashMap<>();
-    public static Map<String, Class<? extends DynamicRegion>> identifierDataMap = new HashMap<>();
-
-    @Override
-    public void load() {
-        INSTANCE = this;
-
-        // Loading all Region Constructor Data that are defined inside the Code
-        constructorDataMap = new BufferedReader(new InputStreamReader(BauSystem.getInstance().getClass().getResourceAsStream("/META-INF/annotations/de.steamwar.bausystem.region.dynamic.RegionConstructorData")))
-                .lines()
-                .map(s -> {
-                    try {
-                        return Class.forName(s, false, BauSystem.getInstance().getClass().getClassLoader());
-                    } catch (ClassNotFoundException | NoClassDefFoundError e) {
-                        throw new SecurityException(e.getMessage(), e);
-                    }
-                })
-                .filter(DynamicRegion.class::isAssignableFrom)
-                .map(clazz -> (Class<? extends DynamicRegion>) clazz)
-                .collect(Collectors.toUnmodifiableMap(Function.identity(), clazz -> clazz.getAnnotation(RegionConstructorData.class)));
-        identifierDataMap = constructorDataMap.entrySet()
-                .stream()
-                .collect(Collectors.toUnmodifiableMap(entry -> entry.getValue().identifier(), Map.Entry::getKey));
-
-        DynamicRegionRepository.loadRegions();
-        new DynamicRegionCommand();
-        new WireframeCommand();
-    }
-
-    @Override
-    public @NonNull Location getWorldSpawn() {
-        return Bukkit.getWorlds().get(0).getSpawnLocation().clone().add(0.5, 0, 0.5); // TODO: Temporary
-    }
-
-    @Override
-    public @NonNull Region getGlobalRegion() {
-        return GlobalRegion.INSTANCE;
-    }
-
-    public Set<Tile> getTilesOfRegion(@NonNull Region region) {
-        Point minPoint = region.getArea().getMinPoint(false);
-        Point maxPoint = region.getArea().getMaxPoint(false);
-
-        Set<Tile> tiles = new HashSet<>();
-        for (int x = minPoint.getX(); x < maxPoint.getX(); x += Tile.tileSize) {
-            for (int z = minPoint.getZ(); z < maxPoint.getZ(); z += Tile.tileSize) {
-                tiles.add(Tile.fromXZ(x, z).orElse(null));
-            }
-        }
-        tiles.remove(null);
-        return Collections.unmodifiableSet(tiles);
-    }
-
-    public @NonNull Region get(@Nullable Tile tile) {
-        return get(tile, true, regionMap.values());
-    }
-
-    private Region get(@Nullable Tile tile, boolean fastCache, Collection<Region> regions) {
-        if (tile == null) return getGlobalRegion();
-        if (regionCache.containsKey(tile.getId())) {
-            Region region = regionCache.get(tile.getId());
-            if (fastCache || regions.contains(region)) return region;
-        }
-        Location location = tile.getCenterLocation();
-        Region region = regions.stream()
-                .filter(rg -> rg.getArea().inRegion(location, false))
-                .findFirst()
-                .orElseGet(this::getGlobalRegion);
-        if (fastCache || regions.contains(region)) {
-            regionCache.put(tile.getId(), region);
-        }
-        return region;
-    }
-
-    @Override
-    public @NonNull Region get(@NonNull Location location) {
-        return get(Tile.fromLocation(location).orElse(null), true, regionMap.values());
-    }
-
-    @Override
-    public Optional<Region> getRegion(@NonNull UUID id) {
-        return Optional.ofNullable(regionMap.get(id));
-    }
-
-    @Override
-    public @NonNull Stream<Region> getRegions() {
-        return regionMap.values().stream();
-    }
-
-    public @NonNull Stream<Region> getRegionsByType(RegionType type) {
-        return regionTypeMap.getOrDefault(type, Collections.emptySet()).stream();
-    }
-
-    public record Neighbour<T extends Region>(T region, Tile tile, NeighbourDirection direction) {
-            public <O extends Region> Neighbour<O> as(Class<O> clazz) {
-                if (!clazz.isInstance(region)) {
-                    return null;
-                } else {
-                    return (Neighbour<O>) this;
-                }
-            }
-
-            @Override
-            public boolean equals(Object o) {
-                if (!(o instanceof Neighbour<?> neighbour)) return false;
-                return Objects.equals(tile, neighbour.tile) && direction == neighbour.direction;
-            }
-
-            @Override
-            public int hashCode() {
-                return Objects.hash(tile, direction);
-            }
-        }
-
-    private Stream<Neighbour<Region>> getNeighbours(Region region, boolean noCorners, boolean fastCache, Collection<Region> regions) {
-        Tile minTile = Tile.fromPoint(region.getArea().getMinPoint(false)).orElse(null);
-        Tile maxTile = Tile.fromPoint(region.getArea().getMaxPoint(false)).orElse(null);
-        if (minTile == null || maxTile == null) return Stream.empty();
-
-        Set<Neighbour<Region>> neighbours = new HashSet<>();
-
-        if (!noCorners) {
-            neighbours.add(new Neighbour<>(get(minTile.add(-1, -1).orElse(null), fastCache, regions), minTile, NeighbourDirection.NorthWest));
-
-            Tile.fromTile(minTile.getTileX(), maxTile.getTileZ()).ifPresent(cornerMinMaxSelf -> {
-                neighbours.add(new Neighbour<>(get(cornerMinMaxSelf.add(-1, 1).orElse(null), fastCache, regions), cornerMinMaxSelf, NeighbourDirection.SouthWest));
-            });
-
-            Tile.fromTile(maxTile.getTileX(), minTile.getTileZ()).ifPresent(cornerMaxMinSelf -> {
-                neighbours.add(new Neighbour<>(get(cornerMaxMinSelf.add(1, -1).orElse(null), fastCache, regions), cornerMaxMinSelf, NeighbourDirection.NorthEast));
-            });
-
-            neighbours.add(new Neighbour<>(get(maxTile.add(1, 1).orElse(null), fastCache, regions), maxTile, NeighbourDirection.SouthEast));
-        }
-
-        for (int x = minTile.getTileX(); x <= maxTile.getTileX(); x++) {
-            Tile.fromTile(x, minTile.getTileZ()).ifPresent(tileMinZSelf -> {
-                neighbours.add(new Neighbour<>(get(tileMinZSelf.add(0, -1).orElse(null), fastCache, regions), tileMinZSelf, NeighbourDirection.North));
-            });
-
-            Tile.fromTile(x, maxTile.getTileZ()).ifPresent(tileMaxZSelf -> {
-                neighbours.add(new Neighbour<>(get(tileMaxZSelf.add(0, 1).orElse(null), fastCache, regions), tileMaxZSelf, NeighbourDirection.South));
-            });
-        }
-
-        for (int z = minTile.getTileZ(); z <= maxTile.getTileZ(); z++) {
-            Tile.fromTile(minTile.getTileX(), z).ifPresent(tileMinXSelf -> {
-                neighbours.add(new Neighbour<>(get(tileMinXSelf.add(-1, 0).orElse(null), fastCache, regions), tileMinXSelf, NeighbourDirection.West));
-            });
-
-            Tile.fromTile(maxTile.getTileX(), z).ifPresent(tileMaxXSelf -> {
-                neighbours.add(new Neighbour<>(get(tileMaxXSelf.add(1, 0).orElse(null), fastCache, regions), tileMaxXSelf, NeighbourDirection.East));
-            });
-        }
-
-        neighbours.removeIf(neighbour -> neighbour.region.getType().isGlobal());
-        return neighbours.stream();
-    }
-
-    public Stream<Neighbour<DynamicRegion>> getNeighbours(Region region) {
-        return getNeighbours(region, false, true, regionMap.values())
-                .map(neighbour -> neighbour.as(DynamicRegion.class))
-                .filter(Objects::nonNull);
-    }
-
-    @Override
-    @NotNull
-    public Stream<Region> getConnectedRegions(@NonNull Region region) {
-        Set<Region> regions = regionTypeMap.get(region.getType());
-
-        Set<Region> connected = new HashSet<>();
-        LinkedHashSet<Region> current = new LinkedHashSet<>();
-        current.add(region);
-
-        while (!current.isEmpty()) {
-            Region r = current.removeFirst();
-            if (!connected.add(r)) continue;
-            getNeighbours(r, true, false, regions)
-                    .map(neighbour -> neighbour.region)
-                    .forEach(current::add);
-        }
-
-        return connected.stream();
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/DynamicRegionVisualizer.java

@@ -1,114 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.region;
-
-import de.steamwar.bausystem.region.dynamic.DynamicRegion;
-import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
-import de.steamwar.bausystem.region.dynamic.Tile;
-import de.steamwar.core.SWPlayer;
-import de.steamwar.entity.*;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.entity.Display;
-import org.bukkit.util.Transformation;
-import org.joml.Quaternionf;
-import org.joml.Vector3f;
-
-public class DynamicRegionVisualizer implements SWPlayer.Component {
-
-    public static final DynamicRegionVisualizer INSTANCE = new DynamicRegionVisualizer();
-
-    private final REntityServer entityServer = new REntityServer();
-
-    private DynamicRegionVisualizer() {
-        RTextDisplay text = new RTextDisplay(entityServer, new Location(null, 0.5, 51.1, 0.5));
-        text.setText("Spawn");
-        text.setBillboard(Display.Billboard.VERTICAL);
-        text.setBackgroundColor(0);
-        text.setShadowed(false);
-        text.setTransform(new Transformation(new Vector3f(0, 0, 0), new Quaternionf().rotationX((float) Math.toRadians(270)), new Vector3f(1, 1, 1), new Quaternionf()));
-    }
-
-    public void addRegion(DynamicRegion region) {
-        new CRegion(entityServer, region);
-    }
-
-    public void removeRegion(DynamicRegion region) {
-        entityServer.getEntitiesByType(CRegion.class)
-                .stream()
-                .filter(cRegion -> cRegion.region == region)
-                .forEach(CRegion::die);
-    }
-
-    @Override
-    public void onMount(SWPlayer player) {
-        entityServer.addPlayer(player.getPlayer());
-    }
-
-    @Override
-    public void onUnmount(SWPlayer player) {
-        entityServer.removePlayer(player.getPlayer());
-    }
-
-    private static final Vector3f VEC_ZERO = new Vector3f(0, 0, 0);
-    private static final Quaternionf QUT_ZERO = new Quaternionf(0, 0, 0, 1);
-
-    public static Point toVisualization(Location worldLocation) {
-        Tile tile = Tile.fromLocation(worldLocation).orElseThrow();
-        return new Point(tile.getTileX(), 50, tile.getTileZ());
-    }
-
-    private static class CRegion extends CEntity {
-
-        private final DynamicRegion region;
-
-        private CRegion(REntityServer server, DynamicRegion region) {
-            super(server);
-            this.region = region;
-
-            RegionConstructorData data = DynamicRegionSystem.constructorDataMap.get(region.getClass());
-            int widthX = data.widthX();
-            int widthZ = data.widthZ();
-
-            Point point = toVisualization(region.getArea().getMinPoint(false).toLocation((World) null));
-
-            if (widthX != 1 || widthZ != 1) {
-                CArea area = new CArea(server);
-                area.setBlock(Material.WHITE_CONCRETE.createBlockData());
-                area.setPos1And2(point.toLocation((World) null).add(0, 1 - CArea.DEFAULT_WIDTH, 0), point.toLocation((World) null).add(widthX - 1, 1 - CArea.DEFAULT_WIDTH, widthZ - 1));
-                entities.add(area);
-
-                RTextDisplay text = new RTextDisplay(server, point.toLocation((World) null).add(widthX / 2.0, 51.1, widthZ / 2.0));
-                text.setText(data.name());
-                text.setBillboard(Display.Billboard.VERTICAL);
-                text.setBackgroundColor(0);
-                text.setShadowed(false);
-                text.setTransform(new Transformation(new Vector3f(0, 0, 0), new Quaternionf().rotationX((float) Math.toRadians(270)), new Vector3f(1, 1, 1), new Quaternionf()));
-                entities.add(text);
-            }
-
-            RBlockDisplay display = new RBlockDisplay(server, point.toLocation((World) null));
-            display.setTransform(new Transformation(VEC_ZERO, QUT_ZERO, new Vector3f(widthX, 1, widthZ), QUT_ZERO));
-            display.setBlock(data.material().createBlockData());
-            entities.add(display);
-        }
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/DynamicRegionVisualizer2.java

@@ -1,80 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.region;
-
-import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
-import de.steamwar.bausystem.region.dynamic.Tile;
-import de.steamwar.bausystem.region.dynamic.path.PathRegion;
-import de.steamwar.core.SWPlayer;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.World;
-
-public class DynamicRegionVisualizer2 implements SWPlayer.Component {
-
-    public static final DynamicRegionVisualizer2 INSTANCE = new DynamicRegionVisualizer2();
-
-    private static final World WORLD = Bukkit.getWorlds().get(0);
-
-    private static final int ORIGIN_X = 10000;
-    private static final int ORIGIN_Z = 10000;
-
-    public DynamicRegionVisualizer2() {
-        if (true) return;
-        // TODO: This is only needed once on startup with a clear beforehand to make the region visualization up to date with the Region Data
-        DynamicRegionSystem.INSTANCE.getRegions().forEach(region -> {
-            RegionConstructorData data = DynamicRegionSystem.constructorDataMap.get(region.getClass());
-            if (data == null) return;
-            int widthX = data.widthX();
-            int widthZ = data.widthZ();
-
-            Material material = data.material();
-            if (region instanceof PathRegion pathRegion && pathRegion.isGarden()) {
-                material = Material.GRASS_BLOCK;
-            }
-
-            Tile tile = Tile.fromPoint(region.getArea().getMinPoint(false)).orElseThrow();
-            for (int x = 0; x < widthX; x++) {
-                for (int z = 0; z < widthZ; z++) {
-                    int cx = x + tile.getTileX() + ORIGIN_X;
-                    int cz = z + tile.getTileZ() + ORIGIN_Z;
-                    WORLD.getBlockAt(cx, 1, cz).setType(material, false);
-                }
-            }
-        });
-    }
-
-    @Override
-    public void onMount(SWPlayer player) {
-        Location location = player.getPlayer().getLocation().clone().multiply(1.0 / Tile.tileSize).add(ORIGIN_X + 0.5, 0, ORIGIN_Z + 0.5);
-        location.setY(10);
-        player.getPlayer().teleport(location);
-        // TODO: Add anything that is needed for setup
-    }
-
-    @Override
-    public void onUnmount(SWPlayer player) {
-        Location location = player.getPlayer().getLocation().clone().subtract(ORIGIN_X + 0.5, 0, ORIGIN_Z + 0.5).multiply(Tile.tileSize);
-        location.setY(50);
-        player.getPlayer().teleport(location.add(0.5, 0, 0.5));
-        // TODO: Add anything that is needed for shutdown
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/DynamicRegion.java

@@ -1,177 +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.region.dynamic;
-
-import com.google.gson.JsonArray;
-import com.google.gson.stream.JsonWriter;
-import de.steamwar.bausystem.region.DynamicRegionSystem;
-import de.steamwar.bausystem.region.Point;
-import de.steamwar.bausystem.region.Region;
-import de.steamwar.bausystem.region.RegionData;
-import de.steamwar.bausystem.region.dynamic.path.PathRegion;
-import de.steamwar.bausystem.region.dynamic.path.PathSide;
-import de.steamwar.bausystem.utils.PasteBuilder;
-import lombok.Getter;
-import lombok.NonNull;
-
-import java.io.IOException;
-import java.util.*;
-
-public abstract class DynamicRegion implements Region {
-
-    protected final UUID id;
-
-    @Getter
-    protected RegionData regionData = null;
-
-    /**
-     * This Constructor should be used if a Region is placed newly onto the world!
-     *
-     * @param tile this parameter is never used but forces the implementor to have it as a parameter
-     */
-    protected DynamicRegion(Tile tile) {
-        this.id = UUID.randomUUID();
-    }
-
-    /**
-     * This constructor is used for loading the Region from a file
-     *
-     * @param id
-     * @param tileData this parameter is never used but forces the implementor to have it as a parameter
-     */
-    protected DynamicRegion(UUID id, JsonArray tileData) {
-        this.id = id;
-    }
-
-    /**
-     * This method should be called when a Region is created and needs to be saved afterward
-     */
-    protected final void finishCreate() {
-        finishLoad();
-        save();
-    }
-
-    /**
-     * This method should be called when a Region is loaded from file!
-     */
-    protected final void finishLoad() {
-        DynamicRegionSystem.INSTANCE.add(this);
-    }
-
-    public abstract void writeTileData(JsonWriter writer) throws IOException;
-
-    public final void updateNeighbours() {
-        List<DynamicRegionSystem.Neighbour<PathRegion>> list = DynamicRegionSystem.INSTANCE.getNeighbours(this)
-                .map(neighbour -> neighbour.as(PathRegion.class))
-                .filter(Objects::nonNull)
-                .toList();
-        // Calculate Garden State for all neighbouring PathRegions
-        Set<UUID> needsFullReset = new HashSet<>();
-        list.forEach(data -> {
-            boolean previousGardenState = data.region().isGarden();
-            PathSide previousToriState = data.region().getToriiSide();
-            data.region().calculateGardenState();
-            data.region().calculateToriiState();
-            if (data.region().isGarden() != previousGardenState) {
-                needsFullReset.add(data.region().getID());
-            } else if (data.region().getToriiSide() != previousToriState) {
-                needsFullReset.add(data.region().getID());
-            }
-        });
-        // Updating world state for all neighbouring PathRegions
-        list.forEach(data -> {
-            if (needsFullReset.contains(data.region().getID())) {
-                data.region().getArea().reset(new PasteBuilder(), false);
-            } else {
-                data.region().update(this, data.direction().opposite());
-            }
-        });
-        // All full reset regions need to update their neighbours!
-        needsFullReset.forEach(uuid -> {
-            Region region = DynamicRegionSystem.INSTANCE.getRegion(uuid).orElse(null);
-            if (!(region instanceof DynamicRegion dynamicRegion)) return;
-            DynamicRegionSystem.INSTANCE.getNeighbours(dynamicRegion)
-                    .map(neighbour -> neighbour.as(PathRegion.class))
-                    .filter(Objects::nonNull)
-                    .forEach(data -> {
-                        if (data.region().isGarden()) return;
-                        data.region().update(dynamicRegion, data.direction().opposite());
-                    });
-        });
-    }
-
-    public void setRegionData(@NonNull RegionData regionData) {
-        this.regionData = regionData;
-        regionData.setStore(this);
-    }
-
-    @NonNull
-    public PathConnectResult shouldPathConnect(Tile source, PathSide side, boolean diagonal) {
-        return PathConnectResult.BY_TYPE;
-    }
-
-    public enum PathConnectResult {
-        ALWAYS,
-        NEVER,
-        BY_TYPE,
-        ;
-
-        public static PathConnectResult of(Boolean result) {
-            return of(result, NEVER);
-        }
-
-        public static PathConnectResult of(Boolean result, PathConnectResult falseResult) {
-            if (result == null) return BY_TYPE;
-            if (result) {
-                return ALWAYS;
-            } else {
-                return falseResult;
-            }
-        }
-    }
-
-    @Override
-    public void delete() {
-        if (!getType().isDeletable()) return;
-        DynamicRegionSystem.INSTANCE.remove(this);
-        DynamicRegionRepository.deleteRegion(this);
-
-        Point minPoint = getArea().getMinPoint(false);
-        Point maxPoint = getArea().getMaxPoint(false);
-        PasteUtils.reset(minPoint, maxPoint);
-
-        this.updateNeighbours();
-    }
-
-    @Override
-    public final @NonNull UUID getID() {
-        return id;
-    }
-
-    @Override
-    public final void save() {
-        DynamicRegionRepository.saveRegion(this);
-    }
-
-    @Override
-    public final void load(RegionData regionData) {
-        DynamicRegionRepository.loadRegionData(this, regionData);
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/DynamicRegionRepository.java

@@ -1,362 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.region.dynamic;
-
-import com.google.gson.*;
-import com.google.gson.stream.JsonWriter;
-import de.steamwar.bausystem.region.*;
-import de.steamwar.bausystem.region.dynamic.path.PathRegion;
-import de.steamwar.bausystem.region.dynamic.path.PathRegionData;
-import de.steamwar.bausystem.region.flags.Flag;
-import lombok.Cleanup;
-import lombok.SneakyThrows;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-
-import java.io.*;
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-import java.nio.file.FileVisitResult;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.SimpleFileVisitor;
-import java.nio.file.attribute.BasicFileAttributes;
-import java.util.UUID;
-import java.util.logging.Level;
-
-@UtilityClass
-public class DynamicRegionRepository {
-
-    // Example regions:
-    // steamwar_regions/
-    // \- 00000000-0000-0000-0000-000000000000/
-    // |  \- flags.json
-    // \- 9494bbf6-b22c-4050-b62b-4be0594ed8ba/
-    //    \- meta.json
-    //    \- flags.json
-    //    \- backups/
-    //       \- MANUAL/
-    //       |  \- 2026.03.01 14:40:00/
-    //       |     \- flags.json
-    //       |     \- backup.schem
-    //       \- AUTOMATIC/
-    //          \- 2026.02.30 12:00:00/
-    //          |  \- flags.json
-    //          |  \- backup.schem
-    //          \- 2026.02.28 19:39:00/
-    //             \- flags.json
-    //             \- backup.schem
-
-    public static final File REGION_DATA_FOLDER = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "steamwar_regions");
-
-    public static final String META_FILE_NAME = "meta.json";
-    public static final String META_FILE_REGION_IDENTIFIER = "region_identifier";
-    @Deprecated
-    private static final String META_FILE_TILE_X = "tile_x";
-    @Deprecated
-    private static final String META_FILE_TILE_Z = "tile_z";
-    public static final String META_FILES_TILES = "tiles";
-
-    public static final String FLAG_FILE_NAME = "flags.json";
-    public static final String BACKUPS_DIR_NAME = "backups";
-    public static final String BACKUP_FILE_NAME = "backup.schem";
-    public static final String FLAGS_KEY = "flags";
-    public static final String PROPERTIES_KEY = "properties";
-
-    static {
-        REGION_DATA_FOLDER.mkdirs();
-    }
-
-    public static void loadRegions() {
-        // Loading all saved regions from the files
-        File[] regions = REGION_DATA_FOLDER.listFiles();
-        for (File region : regions) {
-            UUID regionUUID;
-            try {
-                regionUUID = UUID.fromString(region.getName());
-            } catch (IllegalArgumentException e) {
-                RegionSystem.LOGGER.log(Level.WARNING, "Failed to resolve region id: " + region.getName());
-                continue;
-            }
-            if (regionUUID.equals(RegionSystem.GLOBAL_REGION_ID) || regionUUID.equals(PathRegionData.PATH_REGION_ID)) {
-                continue;
-            }
-
-            File metaFile = new File(region, META_FILE_NAME);
-            if (!metaFile.exists() || !metaFile.isFile()) {
-                RegionSystem.LOGGER.log(Level.WARNING, "Failed to resolve " + region.getName());
-                continue;
-            }
-
-            JsonObject metaData;
-            try {
-                metaData = JsonParser.parseReader(new FileReader(metaFile)).getAsJsonObject();
-            } catch (JsonIOException e) {
-                RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (unknown)");
-                continue;
-            } catch (JsonSyntaxException | IllegalStateException e) {
-                RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (invalid json)");
-                continue;
-            } catch (FileNotFoundException e) {
-                RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (not found)");
-                continue;
-            }
-
-            String identifier;
-            try {
-                identifier = metaData.getAsJsonPrimitive(META_FILE_REGION_IDENTIFIER).getAsString();
-            } catch (ClassCastException | NumberFormatException e) {
-                RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (invalid json)");
-                continue;
-            }
-
-            // TODO: Maybe add static method to DynamicRegionSystem
-            Class<? extends DynamicRegion> regionClass = DynamicRegionSystem.identifierDataMap.get(identifier);
-            if (regionClass == null) {
-                RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (region no longer exists)");
-                continue;
-            }
-
-            JsonArray tileData = metaData.getAsJsonArray(META_FILES_TILES);
-            if (tileData == null) {
-                RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (tile is no longer in bounds)");
-                continue;
-            }
-            constructRegion(regionClass, regionUUID, tileData);
-        }
-
-        // Calculate Garden State for all PathRegions
-        DynamicRegionSystem.INSTANCE.getRegionsByType(RegionType.PATH)
-                .forEach(region -> {
-                    ((PathRegion) region).calculateGardenState();
-                    ((PathRegion) region).calculateToriiState();
-                });
-    }
-
-    public static DynamicRegion constructRegion(Class<? extends DynamicRegion> clazz, Tile tile) {
-        Constructor<? extends DynamicRegion> regionConstructor;
-        try {
-            regionConstructor = clazz.getConstructor(Tile.class);
-        } catch (NoSuchMethodException e) {
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to create region (region constructor not found)");
-            return null;
-        }
-
-        try {
-            return regionConstructor.newInstance(tile);
-        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException |
-                 InvocationTargetException e) {
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to create region (invalid data)");
-            return null;
-        }
-    }
-
-    public static DynamicRegion constructRegion(Class<? extends DynamicRegion> clazz, UUID uuid, JsonArray tileData) {
-        Constructor<? extends DynamicRegion> regionConstructor;
-        try {
-            regionConstructor = clazz.getConstructor(UUID.class, JsonArray.class);
-        } catch (NoSuchMethodException e) {
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (region constructor not found)");
-            return null;
-        }
-
-        try {
-            return regionConstructor.newInstance(uuid, tileData);
-        } catch (InstantiationException | IllegalAccessException | IllegalArgumentException |
-                 InvocationTargetException e) {
-            e.printStackTrace();
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (invalid data)");
-            return null;
-        }
-    }
-
-    private static File getRegionDirectory(UUID uuid) {
-        return new File(REGION_DATA_FOLDER, uuid.toString());
-    }
-
-    public static File getRegionDirectory(Region region) {
-        return getRegionDirectory(region.getID());
-    }
-
-    public static File getBackupsTypeDirectory(Region region, RegionBackups.BackupType backupType) {
-        File regionDirectory = getRegionDirectory(region);
-        File backupsDirectory = new File(regionDirectory, BACKUPS_DIR_NAME);
-        return new File(backupsDirectory, backupType.name());
-    }
-
-    public static File getBackupDirectory(Region region, RegionBackups.Backup backup) {
-        return new File(getBackupsTypeDirectory(region, backup.getType()), backup.getName());
-    }
-
-    public static void loadRegionData(UUID uuid, RegionData regionData) {
-        File regionDirectory = getRegionDirectory(uuid);
-        if (!regionDirectory.exists()) return;
-        loadRegionData(regionDirectory, regionData);
-    }
-
-    public static void loadRegionData(Region region, RegionData regionData) {
-        if (region.getRegionData() instanceof PathRegionData) {
-            return;
-        }
-
-        File regionDirectory = getRegionDirectory(region);
-        if (!regionDirectory.exists()) return;
-        loadRegionData(regionDirectory, regionData);
-    }
-
-    public static void loadRegionData(Region region, RegionBackups.Backup backup, RegionData regionData) {
-        File backupDirectory = getBackupDirectory(region, backup);
-        if (!backupDirectory.exists()) return;
-        loadRegionData(backupDirectory, regionData);
-    }
-
-    private static void loadRegionData(File regionDirectory, RegionData regionData) {
-        JsonObject flagsData;
-        try {
-            flagsData = JsonParser.parseReader(new FileReader(new File(regionDirectory, FLAG_FILE_NAME))).getAsJsonObject();
-        } catch (JsonIOException e) {
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (unknown)");
-            return;
-        } catch (JsonSyntaxException | IllegalStateException e) {
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (invalid json)");
-            return;
-        } catch (FileNotFoundException e) {
-            RegionSystem.LOGGER.log(Level.SEVERE, "Failed to read region metadata file (not found)");
-            return;
-        }
-
-        JsonObject flags = flagsData.getAsJsonObject(FLAGS_KEY);
-        for (String key : flags.keySet()) {
-            Flag flag;
-            try {
-                flag = Flag.valueOf(key);
-            } catch (IllegalArgumentException e) {
-                continue;
-            }
-            String value = flags.getAsJsonPrimitive(key).getAsString();
-            Flag.Value<?> flagValue;
-            try {
-                flagValue = flag.valueOfValue(value);
-            } catch (IllegalArgumentException e) {
-                continue;
-            }
-            regionData.getBackedMap().put(flag, flagValue);
-        }
-
-        JsonObject properties = flagsData.getAsJsonObject(PROPERTIES_KEY);
-        // TODO: Implement!
-    }
-
-    public static void saveRegion(Region region) {
-        if (!(region.getType().isGlobal() || region instanceof DynamicRegion)) {
-            throw new IllegalArgumentException();
-        }
-
-        File regionDirectory = getRegionDirectory(region);
-        if (!regionDirectory.exists()) regionDirectory.mkdir();
-
-        if (region instanceof DynamicRegion dynamicRegion) {
-            RegionConstructorData constructorData = DynamicRegionSystem.constructorDataMap.get(region.getClass());
-            writeMetaFile(regionDirectory, constructorData, dynamicRegion);
-        }
-
-        if (region.getRegionData() instanceof PathRegionData) {
-            return;
-        }
-        writeFlagsFile(regionDirectory, region.getRegionData());
-    }
-
-    public static void saveBackup(Region region, RegionBackups.Backup backup) {
-        File backupDirectory = getBackupDirectory(region, backup);
-        if (!backupDirectory.exists()) {
-            backupDirectory.mkdirs();
-        }
-        writeFlagsFile(backupDirectory, backup.getRegionData());
-    }
-
-    public static void saveData(UUID uuid, RegionData regionData) {
-        File regionDirectory = getRegionDirectory(uuid);
-        writeFlagsFile(regionDirectory, regionData);
-    }
-
-    @SneakyThrows
-    private static void writeMetaFile(File regionDirectory, RegionConstructorData constructorData, DynamicRegion dynamicRegion) {
-        @Cleanup
-        JsonWriter jsonWriter = new JsonWriter(new FileWriter(new File(regionDirectory, META_FILE_NAME)));
-        jsonWriter.setIndent("  ");
-        jsonWriter.beginObject();
-        jsonWriter.name(META_FILE_REGION_IDENTIFIER);
-        jsonWriter.value(constructorData.identifier());
-        jsonWriter.name(META_FILES_TILES);
-        jsonWriter.beginArray();
-        dynamicRegion.writeTileData(jsonWriter);
-        jsonWriter.endArray();
-        jsonWriter.endObject();
-    }
-
-    @SneakyThrows
-    private static void writeFlagsFile(File directory, RegionData regionData) {
-        JsonWriter jsonWriter = new JsonWriter(new FileWriter(new File(directory, FLAG_FILE_NAME)));
-        jsonWriter.setIndent("  ");
-        jsonWriter.beginObject();
-
-        jsonWriter.name(FLAGS_KEY);
-        jsonWriter.beginObject();
-        for (Flag<?> flag : Flag.getFlags()) {
-            if (!regionData.has(flag).isApplicable()) continue;
-            jsonWriter.name(flag.name());
-            jsonWriter.value(regionData.get(flag).nameWithDefault());
-        }
-        jsonWriter.endObject();
-
-        jsonWriter.name(PROPERTIES_KEY);
-        jsonWriter.beginObject();
-        // TODO: Write out needed properties!
-        jsonWriter.endObject();
-
-        jsonWriter.endObject();
-        jsonWriter.close();
-    }
-
-    public static void deleteRegion(Region region) {
-        deleteDir(getRegionDirectory(region));
-    }
-
-    public static void deleteBackup(Region region, RegionBackups.Backup backup) {
-        deleteDir(getBackupDirectory(region, backup));
-    }
-
-    @SneakyThrows
-    private static void deleteDir(File file) {
-        Files.walkFileTree(file.toPath(), new SimpleFileVisitor<>() {
-            @Override
-            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
-                Files.delete(file);
-                return FileVisitResult.CONTINUE;
-            }
-
-            @Override
-            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
-                Files.delete(dir);
-                return FileVisitResult.CONTINUE;
-            }
-        });
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/NeighbourDirection.java

@@ -1,59 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.region.dynamic;
-
-import de.steamwar.bausystem.region.dynamic.path.PathCorner;
-import de.steamwar.bausystem.region.dynamic.path.PathSide;
-import lombok.AllArgsConstructor;
-import lombok.Getter;
-
-import java.util.Set;
-
-@AllArgsConstructor
-@Getter
-public enum NeighbourDirection {
-    North(0, -1, Set.of(PathSide.North), Set.of(PathCorner.NorthEast, PathCorner.NorthWest)),
-    South(0, 1, Set.of(PathSide.South), Set.of(PathCorner.SouthEast, PathCorner.SouthWest)),
-    West(-1, 0, Set.of(PathSide.West), Set.of(PathCorner.NorthWest, PathCorner.SouthWest)),
-    East(1, 0, Set.of(PathSide.East), Set.of(PathCorner.NorthEast, PathCorner.SouthEast)),
-    NorthWest(-1, -1, Set.of(), Set.of(PathCorner.NorthWest)),
-    NorthEast(1, -1, Set.of(), Set.of(PathCorner.NorthEast)),
-    SouthWest(-1, 1, Set.of(), Set.of(PathCorner.SouthWest)),
-    SouthEast(1, 1, Set.of(), Set.of(PathCorner.SouthEast)),
-    ;
-
-    private final int tileOffsetX;
-    private final int tileOffsetZ;
-    private final Set<PathSide> sideUpdates;
-    private final Set<PathCorner> cornerUpdates;
-
-    public NeighbourDirection opposite() {
-        return switch (this) {
-            case North -> South;
-            case South -> North;
-            case East -> West;
-            case West -> East;
-            case NorthWest -> SouthEast;
-            case NorthEast -> SouthWest;
-            case SouthWest -> NorthEast;
-            case SouthEast -> NorthWest;
-        };
-    }
-}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/PasteUtils.java

@@ -1,94 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2026 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.bausystem.region.dynamic;
-
-import com.sk89q.worldedit.EditSession;
-import com.sk89q.worldedit.WorldEdit;
-import com.sk89q.worldedit.bukkit.BukkitAdapter;
-import com.sk89q.worldedit.extent.clipboard.Clipboard;
-import com.sk89q.worldedit.math.BlockVector3;
-import com.sk89q.worldedit.math.transform.AffineTransform;
-import com.sk89q.worldedit.regions.CuboidRegion;
-import com.sk89q.worldedit.world.block.BlockTypes;
-import de.steamwar.bausystem.region.Point;
-import de.steamwar.bausystem.region.Region;
-import de.steamwar.bausystem.utils.FlatteningWrapper;
-import de.steamwar.sql.SchematicData;
-import de.steamwar.sql.SchematicNode;
-import lombok.experimental.UtilityClass;
-import org.bukkit.Bukkit;
-
-import java.io.File;
-import java.io.IOException;
-
-@UtilityClass
-public class PasteUtils {
-
-    // TODO: Create special tiles for global water reset!
-    private static final VariantSelector Reset = VariantSelector.Folder("Wet");
-
-    public static void reset(Point minPoint, Point maxPoint) {
-        if (true) {
-            // TODO: Update to set Water Tile since no longer void world!
-            Tile minTile = Tile.fromPoint(minPoint).orElseThrow();
-            Tile maxTile = Tile.fromPoint(maxPoint).orElseThrow();
-            for (int x = minTile.getTileX(); x <= maxTile.getTileX(); x++) {
-                for (int z = minTile.getTileZ(); z <= maxTile.getTileZ(); z++) {
-                    SchematicNode node = Reset.select().orElseThrow();
-                    paste(node, Tile.fromTile(x, z).orElseThrow().getMinPoint().setY(Region.Area.WORLD_MIN_Y), 0);
-                }
-            }
-            return;
-        }
-
-        EditSession editSession = WorldEdit.getInstance()
-                .newEditSessionBuilder()
-                .world(BukkitAdapter.adapt(Bukkit.getWorlds().get(0)))
-                .checkMemory(false)
-                .allowedRegionsEverywhere()
-                .limitUnlimited()
-                .changeSetNull()
-                .build();
-        editSession.setBlocks((com.sk89q.worldedit.regions.Region) new CuboidRegion(minPoint.toBlockVector3(), maxPoint.toBlockVector3()), BlockTypes.AIR.getDefaultState());
-        editSession.close();
-    }
-
-    public static EditSession paste(File file, Point minPoint, int rotate) {
-        try (Clipboard clipboard = FlatteningWrapper.impl.loadSchematic(file)) {
-            return paste(clipboard, minPoint, rotate);
-        } catch (SecurityException exception) {
-            return null;
-        }
-    }
-
-    public static EditSession paste(SchematicNode schematic, Point minPoint, int rotate) {
-        try (Clipboard clipboard = new SchematicData(schematic).load()) {
-            return paste(clipboard, minPoint, rotate);
-        } catch (SecurityException | IOException exception) {
-            return null;
-        }
-    }
-
-    private static EditSession paste(Clipboard clipboard, Point minPoint, int rotate) {
-        BlockVector3 offset = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin());
-        BlockVector3 to = minPoint.toBlockVector3().subtract(offset);
-        return clipboard.paste(BukkitAdapter.adapt(Bukkit.getWorlds().get(0)), to, false, true, new AffineTransform().rotateY(rotate));
-    }
-}