Optimize some stuff and fix some other stuff

Add MiniWarGear21Region
Add WarGear21Region
Add WarShip21Region

BauSystem/BauSystem_15/src/de/steamwar/bausystem/utils/FlatteningWrapper15.java

@@ -39,6 +39,7 @@ import com.sk89q.worldedit.math.transform.AffineTransform;
 import com.sk89q.worldedit.regions.CuboidRegion;
 import com.sk89q.worldedit.regions.selector.CuboidRegionSelector;
 import com.sk89q.worldedit.session.ClipboardHolder;
+import com.sk89q.worldedit.util.SideEffectSet;
 import com.sk89q.worldedit.world.World;
 import com.sk89q.worldedit.world.block.BaseBlock;
 import com.sk89q.worldedit.world.block.BlockTypes;
@@ -114,6 +115,9 @@ public class FlatteningWrapper15 implements FlatteningWrapper {
 
     @Override
     public Clipboard loadSchematic(File file) {
+        if (file == null) {
+            return null;
+        }
         Clipboard clipboard;
         try (ClipboardReader reader = Objects.requireNonNull(ClipboardFormats.findByFile(file)).getReader(new FileInputStream(file))) {
             clipboard = reader.read();
@@ -167,14 +171,19 @@ public class FlatteningWrapper15 implements FlatteningWrapper {
 
             ClipboardHolder ch = new ClipboardHolder(clipboard);
             BlockVector3 dimensions = clipboard.getDimensions();
-            BlockVector3 v = BlockVector3.at(pasteBuilder.getPastPoint().getX(), pasteBuilder.getPastPoint().getY(), pasteBuilder.getPastPoint().getZ());
+            BlockVector3 v;
             BlockVector3 offset = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin());
+            if (pasteBuilder.getPastPoint() != null) {
+                v = pasteBuilder.getPastPoint().toBlockVector3();
                 if (pasteBuilder.isRotate()) {
                     ch.setTransform(new AffineTransform().rotateY(180));
                     v = v.add(dimensions.getX() / 2, 0, dimensions.getZ() / 2).subtract(offset.multiply(-1, 1, -1)).subtract(0, 0, 1);
                 } else {
                     v = v.subtract(dimensions.getX() / 2, 0, dimensions.getZ() / 2).subtract(offset);
                 }
+            } else {
+                v = pasteBuilder.getMinPoint().toBlockVector3().subtract(offset);
+            }
             pastePoint.set(v);
 
             if (pasteBuilder.isReset()) {
@@ -183,6 +192,7 @@ public class FlatteningWrapper15 implements FlatteningWrapper {
                     e.setBlocks(new CuboidRegion(pasteBuilder.getMinPoint().toBlockVector3(), pasteBuilder.getMaxPoint().toBlockVector3().withY(pasteBuilder.getWaterLevel())), Objects.requireNonNull(BlockTypes.WATER).getDefaultState().toBaseBlock());
                 }
             }
+            e.setSideEffectApplier(SideEffectSet.none());
             Operations.completeBlindly(ch.createPaste(e).to(v).ignoreAirBlocks(pasteBuilder.isIgnoreAir()).build());
             return e;
         } catch (WorldEditException e) {

BauSystem/BauSystem_Main/src/de/steamwar/bausystem/features/bau/BauInfoBauGuiItem.java

@@ -56,6 +56,7 @@ 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.getFlags().has(flag).isApplicable()) continue;
             FlagOptional<?> value = region.getFlags().get(flag);
             if (value.isPresent()) {

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

@@ -20,7 +20,6 @@
 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.flags.Flag;
 import de.steamwar.bausystem.region.flags.ProtectMode;
@@ -42,9 +41,7 @@ public class ProtectListener implements Listener, ScoreboardElement {
     private void explode(List<Block> blockList, Location location) {
         Region region = Region.getRegion(location);
         if (region.getFlags().get(Flag.PROTECT).isWithDefault(ProtectMode.INACTIVE)) return;
-        Point p1 = region.getBuildArea().getMinPoint(true);
-        Point p2 = region.getTestblockArea().getMinPoint(true);
-        int floorLevel = Math.min(p1.getY(), p2.getY());
+        int floorLevel = region.getFloorLevel();
         blockList.removeIf(block -> block.getY() < floorLevel);
     }
 

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

@@ -30,6 +30,7 @@ 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;
@@ -71,7 +72,10 @@ 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 (checkGlobalRegion(region, p)) return;
+        if (region.getHistory() == RegionHistory.EMPTY) {
+            BauSystem.MESSAGE.send("REGION_REGION_NO_REGION", p);
+            return;
+        }
 
         if (region.getHistory().undo()) {
             RegionUtils.message(region, "REGION_REGION_UNDID");
@@ -83,7 +87,8 @@ 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 (checkGlobalRegion(region, p)) {
+        if (region.getHistory() == RegionHistory.EMPTY) {
+            BauSystem.MESSAGE.send("REGION_REGION_NO_REGION", p);
             return;
         }
 

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

@@ -21,9 +21,11 @@ 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;
@@ -185,6 +187,17 @@ public class TestblockCommand extends SWCommand {
 
     private Region regionCheck(Player player) {
         Region region = Region.getRegion(player.getLocation());
+        if (region.getFlags().has(Flag.TESTBLOCK).isWritable() && region.getFlags().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.getFlags().set(Flag.TESTBLOCK, TestblockMode.SOUTH);
+            } else {
+                region.getFlags().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/warp/Warp.java

@@ -22,6 +22,7 @@ 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;
@@ -35,14 +36,20 @@ public class Warp {
     private static Map<String, Warp> warpMap = new HashMap<>();
 
     public static void enable() {
-        Warp worldSpawn = new Warp("WorldSpawn");
-        worldSpawn.setLocation(RegionSystem.INSTANCE.getWorldSpawn());
+        Warp worldSpawn = new Warp("WorldSpawn") {
+            @Override
+            public Location getLocation() {
+                return 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) {
@@ -91,21 +98,13 @@ 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);
     }
 
     public void teleport(Player player) {
-        player.teleport(location, PlayerTeleportEvent.TeleportCause.PLUGIN);
-        player.playSound(location, Sound.ENTITY_ENDERMAN_TELEPORT, SoundCategory.PLAYERS, 1, 1);
+        player.teleport(getLocation(), PlayerTeleportEvent.TeleportCause.PLUGIN);
+        player.playSound(getLocation(), Sound.ENTITY_ENDERMAN_TELEPORT, SoundCategory.PLAYERS, 1, 1);
     }
 }

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

@@ -122,7 +122,7 @@ public class BauScoreboard implements Listener {
                 if (region.getType().isGlobal()) return "§eSteam§8War";
                 String colorCode = "§e";
                 if (region.getFlags().has(Flag.COLOR).isReadable()) {
-                    colorCode = "§" + region.getFlags().get(Flag.COLOR).orElse(ColorMode.PINK).getColorCode();
+                    colorCode = "§" + region.getFlags().get(Flag.COLOR).getWithDefault().getColorCode();
                 }
                 return colorCode + "■ §eSteam§8War " + colorCode + "■"; // ■
             }

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

@@ -37,7 +37,9 @@ public interface FlagStorage {
     @NonNull
     <T extends Enum<T> & Flag.Value<T>> FlagOptional<T> get(@NonNull Flag<T> flag);
 
-    void clear();
+    default void clear() {
+        getBackedMap().clear();
+    }
 
     Map<Flag<?>, Flag.Value<?>> getBackedMap();
 }

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

@@ -35,6 +35,8 @@ import java.util.stream.Collectors;
 @Getter
 public class GameModeConfig {
 
+    public static final GameModeConfig EMPTY = new GameModeConfig(null);
+
     private final boolean loaded;
 
     /**

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

@@ -63,6 +63,12 @@ public interface Region {
     @NonNull
     Area getTestblockArea();
 
+    default int getFloorLevel() {
+        Point p1 = getBuildArea().getMinPoint(true);
+        Point p2 = getTestblockArea().getMinPoint(true);
+        return Math.min(p1.getY(), p2.getY());
+    }
+
     @NonNull
     GameModeConfig getGameModeConfig();
 

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

@@ -41,7 +41,7 @@ public interface RegionBackups {
 
     @RequiredArgsConstructor
     @Getter
-    abstract class Backup {
+    abstract class Backup implements Comparable<Backup> {
         @NonNull
         private final BackupType type;
 
@@ -55,6 +55,13 @@ public interface RegionBackups {
         public abstract boolean load();
 
         public abstract void delete();
+
+        public abstract long getCreationTime();
+
+        @Override
+        public int compareTo(Backup o) {
+            return Long.compare(getCreationTime(), o.getCreationTime());
+        }
     }
 
     @CheckReturnValue

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

@@ -75,6 +75,12 @@ public interface RegionSystem {
     Stream<Region> getRegions();
 
     private static RegionSystem init() {
+        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 |

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

@@ -26,9 +26,31 @@ import lombok.RequiredArgsConstructor;
 @Getter
 public enum RegionType {
 
-    GLOBAL(true),
-    NORMAL(false),
+    GLOBAL(true, false, true, ConnectionType.Global),
+    /**
+     * This should not be used by the DynamicRegionSystem
+     */
+    NORMAL(false, true, false, ConnectionType.Closed),
+
+    SPAWN(false, false, true, ConnectionType.Closed),
+    SPAWN_PATH(false, false, true, ConnectionType.Path),
+    SPAWN_EXTENSION(false, false, false, ConnectionType.Closed),
+    PATH(false, false, false, ConnectionType.Path),
+    DRY(false, true, false, ConnectionType.Closed),
+    DRY_SPECIAL(false, false, false, ConnectionType.Closed),
+    WET(false, true, false, ConnectionType.Water),
+    WET_SPECIAL(false, false, false, ConnectionType.Water),
     ;
 
     private final boolean global;
+    private final boolean createBackup;
+    private final boolean cannotDelete;
+    private final ConnectionType connectionType;
+
+    public enum ConnectionType {
+        Closed,
+        Path,
+        Water,
+        Global
+    }
 }

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

@@ -57,6 +57,19 @@ public class PasteBuilder {
         this.clipboardProvider = clipboardProvider;
     }
 
+    public PasteBuilder with(ClipboardProvider clipboardProvider) {
+        return new PasteBuilder(clipboardProvider)
+                .pastePoint(pastPoint)
+                .rotate(rotate)
+                .ignoreAir(ignoreAir)
+                .reset(reset)
+                .minPoint(minPoint)
+                .maxPoint(maxPoint)
+                .waterLevel(waterLevel)
+                .predicates(predicates)
+                .mappers(mappers);
+    }
+
     public PasteBuilder pastePoint(Point point) {
         this.pastPoint = point;
         return this;
@@ -92,6 +105,16 @@ 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;
@@ -182,11 +205,11 @@ public class PasteBuilder {
     }
 
     public EditSession run() {
-        if (pastPoint == null) {
-            throw new IllegalStateException("pastePoint is null");
-        }
+        if (pastPoint != null || minPoint != null) {
             return FlatteningWrapper.impl.paste(this);
         }
+        throw new IllegalStateException("pastePoint is null");
+    }
 
     public interface ClipboardProvider {
         Clipboard getClipboard();

BauSystem/BauSystem_RegionDynamic/build.gradle.kts

@@ -0,0 +1,46 @@
+/*
+ *   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
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+    targetCompatibility = JavaVersion.VERSION_17
+}
+
+dependencies {
+    compileOnly(project(":BauSystem:BauSystem_Main", "default"))
+    compileOnly(project(":SpigotCore", "default"))
+
+    compileOnly(libs.spigotapi)
+    compileOnly(libs.axiom)
+    compileOnly(libs.authlib)
+    compileOnly(libs.viaapi)
+
+    compileOnly(libs.nms20)
+    compileOnly(libs.fawe18)
+
+    implementation(libs.luaj)
+}

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

@@ -0,0 +1,131 @@
+/*
+ * 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.features.region.RegionCommand;
+import de.steamwar.bausystem.region.dynamic.DynamicRegion;
+import de.steamwar.bausystem.region.dynamic.TileUtils;
+import de.steamwar.bausystem.region.dynamic.normal.display.MicroWarGear21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.display.MiniWarGear21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.display.WarGear21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.display.WarShip21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.MicroWarGear21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.MiniWarGear21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.WarGear21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.WarShip21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.path.PathRegion;
+import de.steamwar.bausystem.region.dynamic.special.DrySpecialRegion;
+import de.steamwar.bausystem.region.dynamic.special.WetSpecialRegion;
+import de.steamwar.bausystem.shared.Pair;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import de.steamwar.command.AbstractSWCommand;
+import de.steamwar.command.SWCommand;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.entity.Player;
+
+import java.util.*;
+import java.util.function.BiFunction;
+import java.util.stream.Collectors;
+
+@AbstractSWCommand.PartOf(RegionCommand.class)
+public class DynamicRegionCommand extends SWCommand {
+
+    public DynamicRegionCommand() {
+        super("");
+    }
+
+    @Register({"dynamic", "place"})
+    public void placeRegion(Player player, Placement placement) {
+        Region region = DynamicRegionSystem.INSTANCE.get(player.getLocation());
+        if (!region.getType().isGlobal()) return;
+        Pair<Integer, Integer> tile = TileUtils.fromLocation(player.getLocation());
+        Pair<Integer, Integer> placePosition = placePosition(tile, placement);
+        if (placePosition == null) return;
+        Pair<Integer, Integer> min = TileUtils.toMinLocation(placePosition);
+
+        DynamicRegion dynamicRegion = placement.constructor.apply(min.getKey(), min.getValue());
+        dynamicRegion.getArea().reset(new PasteBuilder(new PasteBuilder.FileProvider(dynamicRegion.getArea().getResetFile())), false);
+        DynamicRegionSystem.INSTANCE.getNeighbours(dynamicRegion).collect(Collectors.toList())
+                .forEach(r -> r.update(dynamicRegion));
+    }
+
+    private Pair<Integer, Integer> placePosition(Pair<Integer, Integer> sourceTile, Placement placement) {
+        Map<Pair<Integer, Integer>, Region> regionCache = new HashMap<>();
+        Set<Pair<Integer, Integer>> seen = new HashSet<>();
+        LinkedHashSet<Pair<Integer, Integer>> currentTile = new LinkedHashSet<>();
+        currentTile.add(sourceTile);
+        while (!currentTile.isEmpty() && currentTile.size() < (placement.widthX * 2 / 19) * (placement.widthZ * 2 / 19)) {
+            Pair<Integer, Integer> tile = currentTile.removeFirst();
+            if (!seen.add(tile)) continue;
+            if (canPlace(tile, placement, regionCache)) {
+                return tile;
+            }
+
+            for (int dx = -1; dx <= 1; dx++) {
+                for (int dz = -1; dz <= 1; dz++) {
+                    if (dx == 0 && dz == 0) continue;
+                    Pair<Integer, Integer> nextTile = new Pair<>(tile.getKey() + dx, tile.getValue() + dz);
+                    Region region = regionCache.computeIfAbsent(nextTile, tilePair -> Region.getRegion(TileUtils.toMinLocation(tilePair.getKey(), tilePair.getValue())));
+                    if (region.getType().isGlobal()) currentTile.add(nextTile);
+                }
+            }
+        }
+        return null;
+    }
+
+    private boolean canPlace(Pair<Integer, Integer> tile, Placement placement, Map<Pair<Integer, Integer>, Region> regionCache) {
+        for (int x = tile.getKey(); x < tile.getKey() + placement.widthX / TileUtils.tileSize; x++) {
+            for (int z = tile.getValue(); z < tile.getValue() + placement.widthZ / TileUtils.tileSize; z++) {
+                Region region = regionCache.computeIfAbsent(new Pair<>(x, z), tilePair -> Region.getRegion(TileUtils.toMinLocation(tilePair.getKey(), tilePair.getValue())));
+                if (region.getType().isGlobal()) continue;
+                return false;
+            }
+        }
+        return true;
+    }
+
+
+    @RequiredArgsConstructor
+    public enum Placement {
+        Path(PathRegion::new, 19, 19),
+        WetSpecial(WetSpecialRegion::new, 19, 19),
+        DrySpecial(DrySpecialRegion::new, 19, 19),
+        WarGearWork21(WarGear21WorkRegion::new, WarGear21WorkRegion.widthX, WarGear21WorkRegion.widthZ),
+        WarGearDisplay21(WarGear21DisplayRegion::new, WarGear21DisplayRegion.widthX, WarGear21DisplayRegion.widthZ),
+        MiniWarGearWork21(MiniWarGear21WorkRegion::new, MiniWarGear21WorkRegion.widthX, MiniWarGear21WorkRegion.widthZ),
+        MiniWarGearDisplay21(MiniWarGear21DisplayRegion::new, MiniWarGear21DisplayRegion.widthX, MiniWarGear21DisplayRegion.widthZ),
+        WarShipWork21(WarShip21WorkRegion::new, WarShip21WorkRegion.widthX, WarShip21WorkRegion.widthZ),
+        WarShipDisplay21(WarShip21DisplayRegion::new, WarShip21DisplayRegion.widthX, WarShip21DisplayRegion.widthZ),
+        MicroWarGearWork21(MicroWarGear21WorkRegion::new, MicroWarGear21WorkRegion.widthX, MicroWarGear21WorkRegion.widthZ),
+        MicroWarGearDisplay21(MicroWarGear21DisplayRegion::new, MicroWarGear21DisplayRegion.widthX, MicroWarGear21DisplayRegion.widthZ),
+        ;
+
+        private final BiFunction<Integer, Integer, DynamicRegion> constructor;
+        private final int widthX;
+        private final int widthZ;
+    }
+
+    @Register({"dynamic", "delete"})
+    public void deleteRegion(Player player) {
+        Region region = DynamicRegionSystem.INSTANCE.get(player.getLocation());
+        if (region.getType().isCannotDelete()) return;
+        ((DynamicRegion) region).delete();
+    }
+}

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

@@ -0,0 +1,203 @@
+/*
+ * 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 com.comphenix.tinyprotocol.TinyProtocol;
+import de.steamwar.Reflection;
+import de.steamwar.bausystem.BauSystem;
+import de.steamwar.bausystem.region.dynamic.DynamicRegion;
+import de.steamwar.bausystem.region.dynamic.MovementListener;
+import de.steamwar.bausystem.region.dynamic.RegionDataRepository;
+import de.steamwar.bausystem.region.dynamic.global.GlobalRegion;
+import de.steamwar.bausystem.region.dynamic.path.PathRegion;
+import de.steamwar.bausystem.region.dynamic.spawn.SpawnPathRegion;
+import de.steamwar.bausystem.region.dynamic.spawn.SpawnRegion;
+import de.steamwar.bausystem.region.dynamic.spawn.SpawnResetter;
+import de.steamwar.core.Core;
+import de.steamwar.providers.BauServerInfo;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+import org.bukkit.World;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.RecordComponent;
+import java.util.*;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+public class DynamicRegionSystem implements RegionSystem {
+
+    public static DynamicRegionSystem INSTANCE;
+    private static final World WORLD = Bukkit.getWorlds().get(0);
+
+    private static Map<UUID, Region> regionMap = new HashMap<>();
+
+    private Class<?> loginPacket = Reflection.getClass("net.minecraft.network.protocol.game.ClientboundLoginPacket");
+    private Class<?> commonPlayerSpawnInfo = Reflection.getClass("net.minecraft.network.protocol.game.CommonPlayerSpawnInfo");
+    private Reflection.Constructor loginPacketConstructor = Reflection.getConstructor(loginPacket, int.class, boolean.class, Set.class, int.class, int.class, int.class, boolean.class, boolean.class, boolean.class, commonPlayerSpawnInfo, boolean.class);
+    private Class<?> holderClass = Reflection.getClass("net.minecraft.core.Holder");
+    private Class<?> resourceKeyClass = Reflection.getClass("net.minecraft.resources.ResourceKey");
+    private Class<?> gameTypeClass = Reflection.getClass("net.minecraft.world.level.GameType");
+    private Reflection.Constructor commonPlayerSpawnInfoConstructor = Reflection.getConstructor(commonPlayerSpawnInfo, holderClass, resourceKeyClass, long.class, gameTypeClass, gameTypeClass, boolean.class, boolean.class, Optional.class, int.class, int.class);
+    private Class<?> minecraftKeyClass = Reflection.getClass("net.minecraft.resources.MinecraftKey");
+    private Reflection.Constructor resourceKeyConstructor = Reflection.getConstructor(resourceKeyClass, minecraftKeyClass, minecraftKeyClass);
+    private Reflection.Constructor minecraftKeyConstructor = Reflection.getConstructor(minecraftKeyClass, String.class, String.class);
+
+    @Override
+    public void load() {
+        INSTANCE = this;
+        // TODO: Extract into own PR
+        String identifier = BauServerInfo.getOwnerUser().getUUID().toString().replace("-", "");
+        Object resourceKey = resourceKeyConstructor.invoke(minecraftKeyConstructor.invoke("minecraft", "dimension"), minecraftKeyConstructor.invoke("steamwar", "bau/" + Core.getVersion() + "/" + identifier));
+        TinyProtocol.instance.addFilter(loginPacket, (player, o) -> {
+            RecordComponent[] components = loginPacket.getRecordComponents();
+            Object[] parameters_loginPacket = new Object[components.length];
+            for (int i = 0; i < components.length; i++) {
+                try {
+                    parameters_loginPacket[i] = components[i].getAccessor().invoke(o);
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            parameters_loginPacket[2] = Set.of(resourceKey);
+
+            components = commonPlayerSpawnInfo.getRecordComponents();
+            Object[] parameters_commonPlayerSpawnInfo = new Object[components.length];
+            for (int i = 0; i < components.length; i++) {
+                try {
+                    parameters_commonPlayerSpawnInfo[i] = components[i].getAccessor().invoke(parameters_loginPacket[9]);
+                } catch (IllegalAccessException | InvocationTargetException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+            parameters_commonPlayerSpawnInfo[1] = resourceKey;
+            parameters_loginPacket[9] = commonPlayerSpawnInfoConstructor.invoke(parameters_commonPlayerSpawnInfo);
+
+            return loginPacketConstructor.invoke(parameters_loginPacket);
+        });
+        new DynamicRegionCommand();
+        RegionDataRepository.loadRegions();
+        Bukkit.getPluginManager().registerEvents(new MovementListener(), BauSystem.getInstance());
+
+        if (regionMap.isEmpty()) { // TODO: Implement this in default region!
+            new SpawnRegion(-9, -9);
+            new SpawnPathRegion(-9, -28);
+            new SpawnPathRegion(-9, 10);
+            new SpawnPathRegion(-28, -9);
+            new SpawnPathRegion(10, -9);
+
+            new PathRegion(-28, -28);
+            new PathRegion(-28, 10);
+            new PathRegion(10, -28);
+            new PathRegion(10, 10);
+        }
+    }
+
+    public void add(DynamicRegion region) {
+        regionMap.put(region.getID(), region);
+    }
+
+    public void delete(DynamicRegion region) {
+        regionMap.remove(region.getID());
+    }
+
+    @Override
+    public void save() {
+    }
+
+    @Override
+    public @NonNull Location getWorldSpawn() {
+        if (SpawnResetter.isBigSpawn()) {
+            return SpawnResetter.BIG_WORLD_SPAWN;
+        } else {
+            return SpawnResetter.SMALL_WORLD_SPAWN;
+        }
+    }
+
+    @Override
+    public @NonNull Region getGlobalRegion() {
+        return GlobalRegion.INSTANCE;
+    }
+
+    // TODO: Optimize later on!
+    private Region get(Location location, Collection<Region> regions) {
+        return regions.stream()
+                .filter(region -> region.getArea().inRegion(location, false))
+                .findFirst()
+                .orElse(GlobalRegion.INSTANCE);
+    }
+
+    @Override
+    public @NonNull Region get(@NonNull Location location) {
+        return get(location, 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();
+    }
+
+    private Stream<DynamicRegion> getNeighbours(Region region, boolean noCorners, Collection<Region> regions) {
+        Point minPoint = region.getArea().getMinPoint(false).subtract(18, 0, 18);
+        Point maxPoint = region.getArea().getMaxPoint(false).add(19, 0, 19);
+        Set<Region> neighbours = new HashSet<>();
+        for (int x = minPoint.getX() + (noCorners ? 18 : 0); x <= maxPoint.getX() - (noCorners ? 19 : 0); x += 19) {
+            int minZ = minPoint.getZ();
+            int maxZ = maxPoint.getZ();
+            neighbours.add(get(new Location(WORLD, x, 0, minZ), regions));
+            neighbours.add(get(new Location(WORLD, x, 0, maxZ), regions));
+        }
+        for (int z = minPoint.getZ() + 18; z <= maxPoint.getZ() - 19; z += 19) {
+            int minX = minPoint.getX();
+            int maxX = maxPoint.getX();
+            neighbours.add(get(new Location(WORLD, minX, 0, z), regions));
+            neighbours.add(get(new Location(WORLD, maxX, 0, z), regions));
+        }
+        neighbours.remove(GlobalRegion.INSTANCE);
+        return ((Set<DynamicRegion>) (Set) neighbours).stream();
+    }
+
+    public Stream<DynamicRegion> getNeighbours(Region region) {
+        return getNeighbours(region, false, regionMap.values());
+    }
+
+    public Stream<DynamicRegion> getConnectedRegions(DynamicRegion region) {
+        Set<Region> regions = regionMap.values()
+                .stream()
+                .filter(r -> r.getType() == region.getType())
+                .collect(Collectors.toSet());
+
+        Set<DynamicRegion> connectedRegions = new HashSet<>();
+        LinkedHashSet<DynamicRegion> current = new LinkedHashSet<>();
+        current.add(region);
+        while (!current.isEmpty()) {
+            DynamicRegion r = current.removeFirst();
+            if (!connectedRegions.add(r)) continue;
+            getNeighbours(r, true, regions).forEach(current::add);
+        }
+        return connectedRegions.stream();
+    }
+}

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

@@ -0,0 +1,66 @@
+/*
+ * 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.dynamic;
+
+import de.steamwar.bausystem.region.FlagOptional;
+import de.steamwar.bausystem.region.FlagStorage;
+import de.steamwar.bausystem.region.flags.Flag;
+import lombok.NonNull;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Consumer;
+
+public abstract class DefaultFlagStorage implements FlagStorage {
+
+    protected Map<Flag<?>, Flag.Value<?>> flagMap = new HashMap<>();
+    private Consumer<FlagStorage> operation;
+
+    @Override
+    public <T extends Enum<T> & Flag.Value<T>> boolean set(@NonNull Flag<T> flag, @NonNull T value) {
+        if (has(flag).isWritable()) {
+            boolean result = flagMap.put(flag, value) != value;
+            if (operation != null) {
+                operation.accept(this);
+            }
+            return result;
+        } else {
+            return false;
+        }
+    }
+
+    @Override
+    public @NonNull <T extends Enum<T> & Flag.Value<T>> FlagOptional<T> get(@NonNull Flag<T> flag) {
+        return FlagOptional.of(flag, (T) flagMap.get(flag));
+    }
+
+    @Override
+    public Map<Flag<?>, Flag.Value<?>> getBackedMap() {
+        return flagMap;
+    }
+
+    public void setSaveOperation(Consumer<FlagStorage> operation) {
+        this.operation = operation;
+    }
+
+    public void save() {
+        operation.accept(this);
+    }
+}

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

@@ -0,0 +1,104 @@
+/*
+ * 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.dynamic;
+
+import com.sk89q.worldedit.EditSession;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.regions.CuboidRegion;
+import com.sk89q.worldedit.world.block.BlockTypes;
+import de.steamwar.bausystem.region.DynamicRegionSystem;
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.RegionBackups;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+public abstract class DynamicRegion implements Region {
+
+    @Getter
+    protected final UUID ID;
+    protected final int minX;
+    protected final int minZ;
+
+    @Getter
+    protected final RegionBackups backups;
+
+    protected DynamicRegion(int minX, int minZ) {
+        this.ID = UUID.randomUUID();
+        this.minX = minX;
+        this.minZ = minZ;
+        backups = RegionDataRepository.getBackups(this);
+        RegionDataRepository.saveRegion(this);
+        DynamicRegionSystem.INSTANCE.add(this);
+    }
+
+    protected DynamicRegion(RegionConstructorData regionConstructorData) {
+        this.ID = regionConstructorData.uuid;
+        this.minX = regionConstructorData.minX;
+        this.minZ = regionConstructorData.minZ;
+        backups = RegionDataRepository.getBackups(this);
+        RegionDataRepository.saveRegion(this);
+        DynamicRegionSystem.INSTANCE.add(this);
+    }
+
+    public RegionConstructorData getRegionConstructorData() {
+        return new RegionConstructorData.RegionConstructorDataBuilder()
+                .regionClass(this.getClass().getSimpleName())
+                .uuid(ID)
+                .minX(minX)
+                .minZ(minZ)
+                .build();
+    }
+
+    public abstract void update(DynamicRegion updateFrom);
+
+    public abstract void setFlags(DefaultFlagStorage flags);
+
+    @Override
+    public abstract @NonNull DefaultFlagStorage getFlags();
+
+    public void delete() {
+        if (getType().isCannotDelete()) return;
+        DynamicRegionSystem.INSTANCE.delete(this);
+        RegionDataRepository.deleteRegion(this);
+
+        Point minPoint = getArea().getMinPoint(false);
+        Point maxPoint = getArea().getMaxPoint(false);
+
+        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();
+
+        DynamicRegionSystem.INSTANCE.getNeighbours(this).collect(Collectors.toList())
+                .forEach(region -> region.update(this));
+    }
+}

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

@@ -0,0 +1,42 @@
+/*
+ * 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.dynamic;
+
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.shared.Pair;
+import net.md_5.bungee.api.ChatMessageType;
+import net.md_5.bungee.api.chat.TextComponent;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+public class MovementListener implements Listener {
+
+    @EventHandler
+    public void onPlayerMove(PlayerMoveEvent event) {
+        Pair<Integer, Integer> tile = TileUtils.fromLocation(event.getTo());
+        Region region = Region.getRegion(event.getTo());
+        if (tile != null) {
+            event.getPlayer().spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText(tile.getKey() + " : " + tile.getValue() + "   " + region.getType()));
+        } else {
+            event.getPlayer().spigot().sendMessage(ChatMessageType.ACTION_BAR, TextComponent.fromLegacyText("NONE   " + region.getType()));
+        }
+    }
+}

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

@@ -0,0 +1,63 @@
+/*
+ * 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.dynamic;
+
+import de.steamwar.bausystem.region.FlagOptional;
+import de.steamwar.bausystem.region.RegionFlagPolicy;
+import de.steamwar.bausystem.region.flags.ColorMode;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.ProtectMode;
+import de.steamwar.bausystem.region.flags.TNTMode;
+import de.steamwar.core.Core;
+import lombok.NonNull;
+import lombok.ToString;
+
+@ToString
+public class NonNormalFlagStorage extends DefaultFlagStorage {
+
+    public NonNormalFlagStorage() {
+        flagMap.put(Flag.TNT, TNTMode.DENY);
+    }
+
+    @Override
+    public @NonNull <T extends Enum<T> & Flag.Value<T>> RegionFlagPolicy has(@NonNull Flag<T> flag) {
+        if (flag.oneOf(Flag.COLOR)) {
+            return RegionFlagPolicy.READ_ONLY;
+        }
+        if (flag.oneOf(Flag.ITEMS) && Core.getVersion() >= 20) {
+            return RegionFlagPolicy.WRITABLE;
+        }
+        if (flag.oneOf(Flag.TNT, Flag.FIRE, Flag.FREEZE)) {
+            return RegionFlagPolicy.WRITABLE;
+        }
+        return RegionFlagPolicy.NOT_APPLICABLE;
+    }
+
+    @Override
+    public @NonNull <T extends Enum<T> & Flag.Value<T>> FlagOptional<T> get(@NonNull Flag<T> flag) {
+        if (flag.oneOf(Flag.COLOR)) {
+            return FlagOptional.of((Flag) flag, ColorMode.YELLOW);
+        }
+        if (flag.oneOf(Flag.PROTECT)) {
+            return FlagOptional.of((Flag) flag, ProtectMode.INACTIVE);
+        }
+        return super.get(flag);
+    }
+}

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

@@ -0,0 +1,60 @@
+/*
+ * 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.dynamic;
+
+import com.google.gson.JsonObject;
+import com.google.gson.stream.JsonWriter;
+import lombok.AllArgsConstructor;
+import lombok.Builder;
+import lombok.Cleanup;
+import lombok.SneakyThrows;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.util.UUID;
+
+@Builder
+@AllArgsConstructor
+public class RegionConstructorData {
+
+    public final String regionClass;
+    public final UUID uuid;
+    public final int minX;
+    public final int minZ;
+
+    public RegionConstructorData(JsonObject jsonObject, UUID uuid) {
+        regionClass = jsonObject.get("regionClass").getAsString();
+        this.uuid = uuid;
+        minX = jsonObject.get("minX").getAsInt();
+        minZ = jsonObject.get("minZ").getAsInt();
+    }
+
+    @SneakyThrows
+    public void write(File file) {
+        @Cleanup
+        JsonWriter writer = new JsonWriter(new FileWriter(file));
+        writer.setIndent("  ");
+        writer.beginObject();
+        writer.name("regionClass").value(regionClass);
+        writer.name("minX").value(minX);
+        writer.name("minZ").value(minZ);
+        writer.endObject();
+    }
+}

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

@@ -0,0 +1,321 @@
+/*
+ * 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.dynamic;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import com.google.gson.stream.JsonWriter;
+import com.sk89q.worldedit.EditSession;
+import de.steamwar.bausystem.region.FlagStorage;
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.RegionBackups;
+import de.steamwar.bausystem.region.dynamic.normal.NormalFlagStorage;
+import de.steamwar.bausystem.region.dynamic.normal.display.MicroWarGear21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.display.MiniWarGear21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.display.WarGear21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.display.WarShip21DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.MicroWarGear21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.MiniWarGear21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.WarGear21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.normal.work.WarShip21WorkRegion;
+import de.steamwar.bausystem.region.dynamic.path.PathRegion;
+import de.steamwar.bausystem.region.dynamic.spawn.SpawnPathRegion;
+import de.steamwar.bausystem.region.dynamic.spawn.SpawnRegion;
+import de.steamwar.bausystem.region.dynamic.special.DrySpecialRegion;
+import de.steamwar.bausystem.region.dynamic.special.WetSpecialRegion;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.utils.FlatteningWrapper;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import lombok.Cleanup;
+import lombok.NonNull;
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FileWriter;
+import java.io.IOException;
+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.time.LocalDateTime;
+import java.time.format.DateTimeFormatter;
+import java.util.*;
+import java.util.function.Function;
+
+@UtilityClass
+public class RegionDataRepository {
+
+    public static final String META_FILE_NAME = "meta.json";
+    public static final String FLAGS_FILE_NAME = "flags.json";
+    public static final String REGION_SCHEM_FILE_NAME = "region.schem";
+    public static final String BACKUP_DIRECTORY = "backup";
+    private static File regionDataFolder = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "regions");
+    private static Map<String, Function<RegionConstructorData, DynamicRegion>> regionCreators = new HashMap<>();
+    static {
+        regionCreators.put(SpawnRegion.class.getSimpleName(), SpawnRegion::new);
+        regionCreators.put(SpawnPathRegion.class.getSimpleName(), SpawnPathRegion::new);
+        regionCreators.put(PathRegion.class.getSimpleName(), PathRegion::new);
+        regionCreators.put(DrySpecialRegion.class.getSimpleName(), DrySpecialRegion::new);
+        regionCreators.put(WetSpecialRegion.class.getSimpleName(), WetSpecialRegion::new);
+        regionCreators.put(WarGear21WorkRegion.class.getSimpleName(), WarGear21WorkRegion::new);
+        regionCreators.put(WarGear21DisplayRegion.class.getSimpleName(), WarGear21DisplayRegion::new);
+        regionCreators.put("WarGear21Region", WarGear21WorkRegion::new); // TODO: Legacy because of rename
+        regionCreators.put(MiniWarGear21WorkRegion.class.getSimpleName(), MiniWarGear21WorkRegion::new);
+        regionCreators.put(MiniWarGear21DisplayRegion.class.getSimpleName(), MiniWarGear21DisplayRegion::new);
+        regionCreators.put("MiniWarGear21Region", MiniWarGear21WorkRegion::new); // TODO: Legacy because of rename
+        regionCreators.put(WarShip21WorkRegion.class.getSimpleName(), WarShip21WorkRegion::new);
+        regionCreators.put(WarShip21DisplayRegion.class.getSimpleName(), WarShip21DisplayRegion::new);
+        regionCreators.put("WarShip21Region", WarShip21WorkRegion::new); // TODO: Legacy because of rename
+        regionCreators.put(MicroWarGear21WorkRegion.class.getSimpleName(), MicroWarGear21WorkRegion::new);
+        regionCreators.put(MicroWarGear21DisplayRegion.class.getSimpleName(), MicroWarGear21DisplayRegion::new);
+        regionCreators.put("MicroWarGear21Region", MicroWarGear21WorkRegion::new); // TODO: Legacy because of rename
+    }
+
+    static {
+        regionDataFolder.mkdirs();
+    }
+
+    private File getRegionDirectory(Region region) {
+        File file = new File(regionDataFolder, region.getID().toString());
+        file.mkdirs();
+        return file;
+    }
+
+    @SneakyThrows
+    public List<DynamicRegion> loadRegions() {
+        File[] files = regionDataFolder.listFiles();
+        List<DynamicRegion> regions = new ArrayList<>();
+        for (File file : files) {
+            File metaFile = new File(file, META_FILE_NAME);
+            if (!metaFile.exists()) continue;
+            JsonObject jsonObject = JsonParser.parseReader(new FileReader(metaFile)).getAsJsonObject();
+            RegionConstructorData regionConstructorData = new RegionConstructorData(jsonObject, UUID.fromString(file.getName()));
+            Function<RegionConstructorData, DynamicRegion> constructor = regionCreators.get(regionConstructorData.regionClass);
+            if (constructor == null) continue;
+            regions.add(constructor.apply(regionConstructorData));
+        }
+        return regions;
+    }
+
+    public void saveRegion(DynamicRegion region) {
+        File file = getRegionDirectory(region);
+        file = new File(file, META_FILE_NAME);
+        region.getRegionConstructorData()
+                .write(file);
+    }
+
+    public void deleteRegion(DynamicRegion region) {
+        deleteDir(getRegionDirectory(region));
+    }
+
+    public void loadFlagStorage(Region region, DefaultFlagStorage storage) {
+        File file = getRegionDirectory(region);
+        file = new File(file, FLAGS_FILE_NAME);
+        loadFlagStorage(file, storage);
+        if (!file.exists()) saveFlagStorage(region, storage);
+        storage.setSaveOperation(currentStorage -> {
+            saveFlagStorage(region, currentStorage);
+        });
+    }
+
+    @SneakyThrows
+    private void loadFlagStorage(File file, FlagStorage storage) {
+        if (file == null || !file.exists()) return;
+        JsonObject jsonObject = JsonParser.parseReader(new FileReader(file)).getAsJsonObject();
+        for (Flag flag : Flag.getFlags()) {
+            if (!jsonObject.has(flag.name())) continue;
+            Flag.Value<?> value;
+            try {
+                value = flag.valueOfValue(jsonObject.get(flag.name()).getAsString());
+            } catch (IllegalArgumentException e) {
+                continue;
+            }
+            storage.getBackedMap().put(flag, value);
+        }
+    }
+
+    private void saveFlagStorage(Region region, FlagStorage storage) {
+        File file = getRegionDirectory(region);
+        file = new File(file, FLAGS_FILE_NAME);
+        saveFlagStorage(file, storage);
+    }
+
+    @SneakyThrows
+    public void saveFlagStorage(File file, FlagStorage storage) {
+        file.getParentFile().mkdirs();
+
+        @Cleanup
+        JsonWriter jsonWriter = new JsonWriter(new FileWriter(file));
+        jsonWriter.setIndent("  ");
+        jsonWriter.beginObject();
+        for (Map.Entry<Flag<?>, Flag.Value<?>> entry : storage.getBackedMap().entrySet()) {
+            if (entry.getKey() == Flag.CHANGED) continue;
+            jsonWriter.name(entry.getKey().name());
+            jsonWriter.value(entry.getValue().name());
+        }
+        jsonWriter.endObject();
+    }
+
+    private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy.MM.dd'_'HH:mm:ss");
+    public RegionBackups getBackups(DynamicRegion region) {
+        if (!region.getType().isCreateBackup()) {
+            return RegionBackups.EMPTY;
+        }
+
+        File directory = new File(getRegionDirectory(region), BACKUP_DIRECTORY);
+        directory.mkdirs();
+        return new RegionBackups() {
+            private List<Backup> backups = new ArrayList<>();
+
+            {
+                File[] files = directory.listFiles();
+                if (files != null) {
+                    for (File file : files) {
+                        backups.add(new BackupImpl(file, region));
+                    }
+                }
+                backups.sort(null);
+            }
+
+            @Override
+            @SneakyThrows
+            public Optional<Backup> create(BackupType backupType) {
+                String name = LocalDateTime.now().format(formatter);
+                File backupDirectory = new File(directory, name);
+                backupDirectory.mkdirs();
+
+                Point minPoint = region.getArea().getMinPoint(false);
+                Point maxPoint = region.getArea().getMaxPoint(false);
+                boolean success = FlatteningWrapper.impl.backup(minPoint, maxPoint, new File(backupDirectory, REGION_SCHEM_FILE_NAME));
+                if (!success) {
+                    deleteDir(backupDirectory);
+                    return Optional.empty();
+                }
+
+                int count = 0;
+                for (int i = backups.size() - 1; i >= 0; i--) {
+                    Backup backup = backups.get(i);
+                    if (backup.getType() == backupType) {
+                        if (count >= backupType.maxBackups - 1) {
+                            backup.delete();
+                            backups.remove(i);
+                            continue;
+                        }
+                        count++;
+                    }
+                }
+
+                new File(backupDirectory, backupType.name()).createNewFile();
+                saveFlagStorage(new File(backupDirectory, FLAGS_FILE_NAME), region.getFlags());
+                Backup backup = new BackupImpl(backupDirectory, region);
+                backups.add(backup);
+                return Optional.of(backup);
+            }
+
+            @Override
+            public @NonNull List<Backup> list() {
+                return backups;
+            }
+
+            @Nullable
+            @Override
+            public Backup get(String name) {
+                for (Backup backup : backups) {
+                    if (backup.getName().equals(name)) {
+                        return backup;
+                    }
+                }
+                return null;
+            }
+        };
+    }
+
+    private static class BackupImpl extends RegionBackups.Backup {
+        private final File file;
+        private final DynamicRegion region;
+
+        public BackupImpl(File file, DynamicRegion region) {
+            super(getType(file), file.getName(), getFlags(file));
+            this.file = file;
+            this.region = region;
+        }
+
+        private static RegionBackups.BackupType getType(File file) {
+            for (RegionBackups.BackupType type : RegionBackups.BackupType.values()) {
+                if (new File(file, type.name()).exists()) return type;
+            }
+            throw new IllegalArgumentException("Unknown backup type");
+        }
+
+        private static FlagStorage getFlags(File file) {
+            NormalFlagStorage storage = new NormalFlagStorage();
+            loadFlagStorage(new File(file, FLAGS_FILE_NAME), storage);
+            return storage;
+        }
+
+        @Override
+        public boolean load() {
+            if (!file.exists()) return false;
+            EditSession editSession = new PasteBuilder(new PasteBuilder.FileProvider(new File(file, REGION_SCHEM_FILE_NAME)))
+                    .pastePoint(region.getArea().getMinPoint(false))
+                    .minPoint(region.getArea().getMinPoint(false))
+                    .maxPoint(region.getArea().getMaxPoint(false))
+                    .run();
+            region.getHistory().remember(editSession);
+            region.getFlags().setSaveOperation(null);
+            region.setFlags((DefaultFlagStorage) getFlags());
+            region.getFlags().setSaveOperation(storage -> saveFlagStorage(region, storage));
+            return true;
+        }
+
+        @Override
+        public void delete() {
+            deleteDir(file);
+        }
+
+        @Override
+        public long getCreationTime() {
+            return file.lastModified();
+        }
+    }
+
+    @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/TileUtils.java

@@ -0,0 +1,48 @@
+/*
+ * 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.dynamic;
+
+import de.steamwar.bausystem.shared.Pair;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Location;
+
+@UtilityClass
+public class TileUtils {
+
+    public static final int tileSize = 19;
+    public static final int minTile = -1023;
+    public static final int maxTile = 1023;
+
+    public Pair<Integer, Integer> fromLocation(Location location) {
+        int x = (int) Math.floor((location.getBlockX() + 9) / (double) tileSize);
+        int z = (int) Math.floor((location.getBlockZ() + 9) / (double) tileSize);
+        if (x < minTile || z < minTile) return null;
+        if (x > maxTile || z > maxTile) return null;
+        return new Pair<>(x, z);
+    }
+
+    public Pair<Integer, Integer> toMinLocation(Pair<Integer, Integer> tile) {
+        return new Pair<>(tile.getKey() * tileSize - 9, tile.getValue() * tileSize - 9);
+    }
+
+    public Location toMinLocation(int tileX, int tileZ) {
+        return new Location(null, tileX * tileSize - 9, 0, tileZ * tileSize - 9);
+    }
+}

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

@@ -0,0 +1,69 @@
+/*
+ * 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.dynamic;
+
+import lombok.NonNull;
+
+import java.io.File;
+import java.time.LocalDate;
+import java.util.Objects;
+import java.util.Optional;
+import java.util.Random;
+
+public interface VariantSelector {
+
+    Optional<File> selectVariant(int minX, int minZ);
+
+    default VariantSelector or(VariantSelector other) {
+        return (minX, minZ) -> selectVariant(minX, minZ).or(() -> other.selectVariant(minX, minZ));
+    }
+
+    static VariantSelector AtDate(int day, int month, File file) {
+        return (minX, minZ) -> {
+            LocalDate date = LocalDate.now();
+            if (date.getDayOfMonth() == day && date.getMonthValue() == month) {
+                return Optional.of(file);
+            } else {
+                return Optional.empty();
+            }
+        };
+    }
+
+    static VariantSelector File(@NonNull File file) {
+        return (minX, minZ) -> Optional.of(file);
+    }
+
+    static VariantSelector StableVariants(@NonNull File directory) {
+        File[] files = directory.listFiles();
+        Random rand = new Random();
+        return (minX, minZ) -> {
+            rand.setSeed(Objects.hash(minX, minZ));
+            return Optional.of(files[rand.nextInt(files.length)]);
+        };
+    }
+
+    static VariantSelector RandomVariants(@NonNull File directory) {
+        File[] files = directory.listFiles();
+        Random rand = new Random();
+        return (minX, minZ) -> {
+            return Optional.of(files[rand.nextInt(files.length)]);
+        };
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/global/GlobalRegion.java

@@ -0,0 +1,144 @@
+/*
+ * 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.dynamic.global;
+
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import de.steamwar.bausystem.region.*;
+import de.steamwar.bausystem.region.dynamic.DefaultFlagStorage;
+import de.steamwar.bausystem.region.dynamic.NonNormalFlagStorage;
+import de.steamwar.bausystem.region.dynamic.RegionDataRepository;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import lombok.NonNull;
+import org.bukkit.Location;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.util.UUID;
+import java.util.function.BiConsumer;
+
+public class GlobalRegion implements Region {
+
+    public static final GlobalRegion INSTANCE = new GlobalRegion();
+
+    private static final Point MIN_POINT = new Point(Integer.MIN_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE);
+    private static final Point MAX_POINT = new Point(Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE);
+
+    private static final UUID GLOBAL_REGION_ID = new UUID(0, 0);
+
+    private static final Region.Area GLOBAL_AREA = new Region.Area() {
+        @Override
+        public @NonNull Point getMinPoint(boolean extension) {
+            return MIN_POINT;
+        }
+
+        @Override
+        public @NonNull Point getMaxPoint(boolean extension) {
+            return MAX_POINT;
+        }
+
+        @Override
+        public @NonNull Point getCopyPoint() {
+            return Point.ZERO;
+        }
+
+        @Override
+        public boolean inRegion(Location location, boolean extension) {
+            return true;
+        }
+
+        @Nullable
+        @Override
+        public Clipboard copy(boolean extension) {
+            return null;
+        }
+
+        @Nullable
+        @Override
+        public File getResetFile() {
+            return null;
+        }
+
+        @Override
+        public void reset(PasteBuilder pasteBuilder, boolean extension) {
+        }
+
+        @Override
+        public void forEachChunk(BiConsumer<Integer, Integer> executor) {
+        }
+
+        @Override
+        public boolean isChunkOutside(int chunkX, int chunkZ) {
+            return false;
+        }
+    };
+
+    private static DefaultFlagStorage FLAG_STORAGE = new NonNormalFlagStorage();
+    static {
+        RegionDataRepository.loadFlagStorage(INSTANCE, FLAG_STORAGE);
+    }
+
+    private GlobalRegion() {
+    }
+
+    @Override
+    public RegionType getType() {
+        return RegionType.GLOBAL;
+    }
+
+    @Override
+    public @NonNull UUID getID() {
+        return GLOBAL_REGION_ID;
+    }
+
+    @Override
+    public @NonNull FlagStorage getFlags() {
+        return FLAG_STORAGE;
+    }
+
+    @Override
+    public @NonNull Region.Area getArea() {
+        return GLOBAL_AREA;
+    }
+
+    @Override
+    public @NonNull Region.Area getBuildArea() {
+        return Region.Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull Region.Area getTestblockArea() {
+        return Region.Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull GameModeConfig getGameModeConfig() {
+        return GameModeConfig.EMPTY;
+    }
+
+    @Override
+    public @NonNull RegionHistory getHistory() {
+        return RegionHistory.EMPTY;
+    }
+
+    @Override
+    public @NonNull RegionBackups getBackups() {
+        return RegionBackups.EMPTY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/DisplayRegion.java

@@ -0,0 +1,69 @@
+/*
+ * 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.dynamic.normal;
+
+import de.steamwar.bausystem.region.RegionHistory;
+import de.steamwar.bausystem.region.dynamic.DefaultFlagStorage;
+import de.steamwar.bausystem.region.dynamic.DynamicRegion;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.RegionDataRepository;
+import lombok.Getter;
+import lombok.NonNull;
+
+public abstract class DisplayRegion extends DynamicRegion {
+
+    @Getter
+    private DefaultFlagStorage flags = new NormalFlagStorage();
+
+    @Getter
+    protected NormalArea area = NormalArea.EMPTY;
+
+    @Getter
+    private final RegionHistory history = new RegionHistory.Impl(20);
+
+    protected DisplayRegion(int minX, int minZ) {
+        super(minX, minZ);
+        RegionDataRepository.loadFlagStorage(this, flags);
+    }
+
+    protected DisplayRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        RegionDataRepository.loadFlagStorage(this, flags);
+    }
+
+    @Override
+    public void update(DynamicRegion updateFrom) {
+    }
+
+    @Override
+    public void setFlags(DefaultFlagStorage flags) {
+        this.flags = flags;
+    }
+
+    @Override
+    public @NonNull Area getBuildArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull Area getTestblockArea() {
+        return Area.EMPTY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/NormalArea.java

@@ -0,0 +1,126 @@
+/*
+ * 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.dynamic.normal;
+
+import com.sk89q.worldedit.EditSession;
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import lombok.NonNull;
+import org.bukkit.Location;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.util.function.BiConsumer;
+
+public class NormalArea implements Region.Area {
+
+    public static final NormalArea EMPTY = new NormalArea(0, 0, 0, 0, 0, 0, null, false, null) {
+        @Override
+        public void reset(PasteBuilder pasteBuilder, boolean extension) {
+        }
+
+        @Override
+        public boolean isEmpty() {
+            return true;
+        }
+
+        @Override
+        public boolean inRegion(Location location, boolean extension) {
+            return false;
+        }
+
+        @Override
+        public void forEachChunk(BiConsumer<Integer, Integer> executor) {
+        }
+
+        @Override
+        public boolean isChunkOutside(int chunkX, int chunkZ) {
+            return true;
+        }
+    };
+
+    private final int minX;
+    private final int minY;
+    private final int minZ;
+    private final int widthX;
+    private final int widthY;
+    private final int widthZ;
+    private VariantSelector variantSelector;
+    private final Point minPoint;
+    private final Point maxPoint;
+    private final Point copyPoint;
+    private final boolean rotate;
+    private final Region region;
+
+    public NormalArea(int minX, int minY, int minZ, int widthX, int widthY, int widthZ, VariantSelector variantSelector, boolean rotate, Region region) {
+        this.minX = minX;
+        this.minY = minY;
+        this.minZ = minZ;
+        this.widthX = widthX;
+        this.widthY = widthY;
+        this.widthZ = widthZ;
+        this.variantSelector = variantSelector;
+        this.rotate = rotate;
+        this.region = region;
+
+        minPoint = new Point(minX, minY, minZ);
+        maxPoint = new Point(minX + widthX - 1, minY + widthY - 1, minZ + widthZ - 1);
+        copyPoint = minPoint.add(widthX / 2, widthY, widthZ / 2);
+    }
+
+    @Override
+    public @NonNull Point getMinPoint(boolean extension) {
+        return minPoint;
+    }
+
+    @Override
+    public @NonNull Point getMaxPoint(boolean extension) {
+        return maxPoint;
+    }
+
+    @Override
+    public @NonNull Point getCopyPoint() {
+        return copyPoint;
+    }
+
+    public NormalArea setResetFile(VariantSelector variantSelector) {
+        this.variantSelector = variantSelector;
+        return this;
+    }
+
+    @Nullable
+    @Override
+    public File getResetFile() {
+        return variantSelector.selectVariant(minX, minZ).orElseThrow();
+    }
+
+    @Override
+    public void reset(PasteBuilder pasteBuilder, boolean extension) {
+        EditSession editSession = pasteBuilder.minPoint(minPoint)
+                .maxPoint(maxPoint)
+                .rotate(rotate)
+                .color(region.getFlags().get(Flag.COLOR).getWithDefault())
+                .run();
+        region.getHistory().remember(editSession);
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/NormalFlagStorage.java

@@ -0,0 +1,42 @@
+/*
+ * 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.dynamic.normal;
+
+import de.steamwar.bausystem.region.RegionFlagPolicy;
+import de.steamwar.bausystem.region.dynamic.DefaultFlagStorage;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.core.Core;
+import lombok.NonNull;
+import lombok.ToString;
+
+@ToString
+public class NormalFlagStorage extends DefaultFlagStorage {
+
+    @Override
+    public @NonNull <T extends Enum<T> & Flag.Value<T>> RegionFlagPolicy has(@NonNull Flag<T> flag) {
+        if (flag.oneOf(Flag.COLOR, Flag.TNT, Flag.FIRE, Flag.FREEZE, Flag.PROTECT, Flag.NO_GRAVITY, Flag.TESTBLOCK, Flag.CHANGED)) {
+            return RegionFlagPolicy.WRITABLE;
+        }
+        if (flag.oneOf(Flag.ITEMS) && Core.getVersion() >= 20) {
+            return RegionFlagPolicy.WRITABLE;
+        }
+        return RegionFlagPolicy.NOT_APPLICABLE;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/WorkRegion.java

@@ -0,0 +1,90 @@
+/*
+ * 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.dynamic.normal;
+
+import de.steamwar.bausystem.region.FlagOptional;
+import de.steamwar.bausystem.region.RegionHistory;
+import de.steamwar.bausystem.region.dynamic.*;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.TestblockMode;
+import lombok.Getter;
+import lombok.NonNull;
+
+public abstract class WorkRegion extends DynamicRegion {
+
+    @Getter
+    private DefaultFlagStorage flags = new NormalFlagStorage();
+
+    @Getter
+    protected NormalArea area = NormalArea.EMPTY;
+    protected NormalArea northArea = NormalArea.EMPTY;
+    protected NormalArea southArea = NormalArea.EMPTY;
+
+    protected VariantSelector frame;
+    protected VariantSelector testblock;
+
+    @Getter
+    private final RegionHistory history = new RegionHistory.Impl(20);
+
+    protected WorkRegion(int minX, int minZ) {
+        super(minX, minZ);
+        RegionDataRepository.loadFlagStorage(this, flags);
+    }
+
+    protected WorkRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        RegionDataRepository.loadFlagStorage(this, flags);
+    }
+
+    @Override
+    public void update(DynamicRegion updateFrom) {
+    }
+
+    @Override
+    public void setFlags(DefaultFlagStorage flags) {
+        this.flags = flags;
+    }
+
+    @Override
+    public @NonNull Area getBuildArea() {
+        FlagOptional<TestblockMode> testblock = flags.get(Flag.TESTBLOCK);
+        if (testblock.isWithDefault(TestblockMode.NO_VALUE)) {
+            return Area.EMPTY;
+        }
+        if (testblock.isWithDefault(TestblockMode.SOUTH)) {
+            return northArea.setResetFile(this.frame);
+        } else {
+            return southArea.setResetFile(this.frame);
+        }
+    }
+
+    @Override
+    public @NonNull Area getTestblockArea() {
+        FlagOptional<TestblockMode> testblock = flags.get(Flag.TESTBLOCK);
+        if (testblock.isWithDefault(TestblockMode.NO_VALUE)) {
+            return Area.EMPTY;
+        }
+        if (testblock.isWithDefault(TestblockMode.SOUTH)) {
+            return southArea.setResetFile(this.testblock);
+        } else {
+            return northArea.setResetFile(this.testblock);
+        }
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/display/MicroWarGear21DisplayRegion.java

@@ -0,0 +1,59 @@
+/*
+ * 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.dynamic.normal.display;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class MicroWarGear21DisplayRegion extends DisplayRegion {
+
+    public static final int widthX = 57;
+    public static final int widthZ = 57;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/microwargear21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Display.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public MicroWarGear21DisplayRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    public MicroWarGear21DisplayRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/display/MiniWarGear21DisplayRegion.java

@@ -0,0 +1,59 @@
+/*
+ * 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.dynamic.normal.display;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class MiniWarGear21DisplayRegion extends DisplayRegion {
+
+    public static final int widthX = 57;
+    public static final int widthZ = 38;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/miniwargear21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Display.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public MiniWarGear21DisplayRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    public MiniWarGear21DisplayRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/display/WarGear21DisplayRegion.java

@@ -0,0 +1,59 @@
+/*
+ * 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.dynamic.normal.display;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class WarGear21DisplayRegion extends DisplayRegion {
+
+    public static final int widthX = 133;
+    public static final int widthZ = 95;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/wargear21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Display.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public WarGear21DisplayRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    public WarGear21DisplayRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/display/WarShip21DisplayRegion.java

@@ -0,0 +1,59 @@
+/*
+ * 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.dynamic.normal.display;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.DisplayRegion;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class WarShip21DisplayRegion extends DisplayRegion {
+
+    public static final int widthX = 266;
+    public static final int widthZ = 95;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/warship21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Display.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public WarShip21DisplayRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    public WarShip21DisplayRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/work/MicroWarGear21WorkRegion.java

@@ -0,0 +1,69 @@
+/*
+ * 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.dynamic.normal.work;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import de.steamwar.bausystem.region.dynamic.normal.WorkRegion;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class MicroWarGear21WorkRegion extends WorkRegion {
+
+    public static final int widthX = 57;
+    public static final int widthZ = 114;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/microwargear21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Work.schem");
+    private static final File FRAME_FILE = new File(MODE_DIR, "Frame.schem");
+    private static final File TESTBLOCK_FILE = new File(MODE_DIR, "Testblock.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public MicroWarGear21WorkRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 25, 32, minZ + 25, 7, 7, 7, null, false, this);
+        southArea = new NormalArea(minX + 25, 32, minZ + 82, 7, 7, 7, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    public MicroWarGear21WorkRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 25, 32, minZ + 25, 7, 7, 7, null, false, this);
+        southArea = new NormalArea(minX + 25, 32, minZ + 82, 7, 7, 7, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/work/MiniWarGear21WorkRegion.java

@@ -0,0 +1,69 @@
+/*
+ * 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.dynamic.normal.work;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import de.steamwar.bausystem.region.dynamic.normal.WorkRegion;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class MiniWarGear21WorkRegion extends WorkRegion {
+
+    public static final int widthX = 95;
+    public static final int widthZ = 152;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/miniwargear21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Work.schem");
+    private static final File FRAME_FILE = new File(MODE_DIR, "Frame.schem");
+    private static final File TESTBLOCK_FILE = new File(MODE_DIR, "Testblock.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public MiniWarGear21WorkRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 29, 32, minZ + 29, 37, 26, 22, null, false, this);
+        southArea = new NormalArea(minX + 29, 32, minZ + 101, 37, 26, 22, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    public MiniWarGear21WorkRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 29, 32, minZ + 29, 37, 26, 22, null, false, this);
+        southArea = new NormalArea(minX + 29, 32, minZ + 101, 37, 26, 22, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/work/WarGear21WorkRegion.java

@@ -0,0 +1,69 @@
+/*
+ * 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.dynamic.normal.work;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import de.steamwar.bausystem.region.dynamic.normal.WorkRegion;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class WarGear21WorkRegion extends WorkRegion {
+
+    public static final int widthX = 133;
+    public static final int widthZ = 228;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/wargear21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Work.schem");
+    private static final File FRAME_FILE = new File(MODE_DIR, "Frame.schem");
+    private static final File TESTBLOCK_FILE = new File(MODE_DIR, "Testblock.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public WarGear21WorkRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 33, 32, minZ + 42, 67, 41, 47, null, false, this);
+        southArea = new NormalArea(minX + 33, 32, minZ + 139, 67, 41, 47, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    public WarGear21WorkRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 33, 32, minZ + 42, 67, 41, 47, null, false, this);
+        southArea = new NormalArea(minX + 33, 32, minZ + 139, 67, 41, 47, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/normal/work/WarShip21WorkRegion.java

@@ -0,0 +1,69 @@
+/*
+ * 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.dynamic.normal.work;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.region.dynamic.normal.NormalArea;
+import de.steamwar.bausystem.region.dynamic.normal.WorkRegion;
+import lombok.Getter;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class WarShip21WorkRegion extends WorkRegion {
+
+    public static final int widthX = 285;
+    public static final int widthZ = 228;
+
+    private static final File MODE_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/regions/warship21/");
+    private static final File REGION_FILE = new File(MODE_DIR, "Work.schem");
+    private static final File FRAME_FILE = new File(MODE_DIR, "Frame.schem");
+    private static final File TESTBLOCK_FILE = new File(MODE_DIR, "Testblock.schem");
+
+    @Getter
+    private final GameModeConfig gameModeConfig = new GameModeConfig(null); // TODO: Implement
+
+    public WarShip21WorkRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 28, 19, minZ + 25, 230, 58, 43, null, false, this);
+        southArea = new NormalArea(minX + 28, 19, minZ + 160, 230, 58, 43, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    public WarShip21WorkRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new NormalArea(minX, 0, minZ, widthX, 255, widthZ, VariantSelector.File(REGION_FILE), false, this);
+        northArea = new NormalArea(minX + 28, 19, minZ + 25, 230, 58, 43, null, false, this);
+        southArea = new NormalArea(minX + 28, 19, minZ + 160, 230, 58, 43, null, true, this);
+        frame = VariantSelector.File(FRAME_FILE);
+        testblock = VariantSelector.File(TESTBLOCK_FILE);
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.WET;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/path/PathAreaTile.java

@@ -0,0 +1,162 @@
+/*
+ * 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.dynamic.path;
+
+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 de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.RegionSystem;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.utils.FlatteningWrapper;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import lombok.NonNull;
+import lombok.RequiredArgsConstructor;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+
+import javax.annotation.Nullable;
+import java.io.File;
+import java.util.function.Function;
+
+public class PathAreaTile implements Region.Area { // TODO: Change to VariantSelector
+
+    private static final File PATH_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections/path");
+    private static final File PATH_CENTER = new File(PATH_DIR, "PathCenter.schem");
+
+    @RequiredArgsConstructor
+    private enum Path {
+        North(0, -18, 5, 0, 0),
+        South(0, 19, 5, 0, 180),
+        West(-18, 0, 5, 0, 90),
+        East(19, 0, 5, 0, 270),
+        ;
+
+        private final int checkX;
+        private final int checkZ;
+        private final int pasteX;
+        private final int pasteZ;
+        private final int rotate;
+
+        private static final Function<RegionType.ConnectionType, File> function = connectionType -> {
+            return new File(PATH_DIR, "PathEdge" + connectionType.name() + ".schem");
+        };
+    }
+
+    @RequiredArgsConstructor
+    private enum PathCorner {
+        NorthEast(Path.North, Path.East, 14, 0, 0),
+        EastSouth(Path.East, Path.South, 14, 0, 270),
+        SouthWest(Path.South, Path.West, 14, 0, 180),
+        WestNorth(Path.West, Path.North, 14, 0, 90),
+        ;
+
+        private final Path check1;
+        private final Path check2;
+        private final int pasteX;
+        private final int pasteZ;
+        private final int rotate;
+
+        private static final TriFunction<RegionType.ConnectionType, RegionType.ConnectionType, RegionType.ConnectionType, File> function = (connectionType1, connectionType2, connectionTypeCorner) -> {
+            return new File(PATH_DIR, "PathCorner" + connectionType1.name() + connectionType2.name() + connectionTypeCorner.name() + ".schem");
+        };
+
+        private interface TriFunction<T, U, V, W> {
+            W apply(T t, U u, V v);
+        }
+    }
+
+    private final int minX;
+    private final int minZ;
+    private final Point minPoint;
+    private final Point maxPoint;
+    private final Point copyPoint;
+    private final Region region;
+
+    public PathAreaTile(int minX, int minZ, Region region) {
+        this.minX = minX;
+        this.minZ = minZ;
+
+        minPoint = new Point(minX, 0, minZ);
+        maxPoint = new Point(minX + 18, 255, minZ + 18);
+        copyPoint = new Point(minX + 9, 0, minZ + 9);
+
+        this.region = region;
+    }
+
+    @Override
+    public @NonNull Point getMinPoint(boolean extension) {
+        return minPoint;
+    }
+
+    @Override
+    public @NonNull Point getMaxPoint(boolean extension) {
+        return maxPoint;
+    }
+
+    @Override
+    public @NonNull Point getCopyPoint() {
+        return copyPoint;
+    }
+
+    @Nullable
+    @Override
+    public File getResetFile() {
+        return null; // I know what I do!
+    }
+
+    @Override
+    public void reset(PasteBuilder pasteBuilder, boolean extension) {
+        Point minPoint = getMinPoint(false);
+
+        paste(PATH_CENTER, minPoint.add(5, 0, 5), 0);
+
+        for (Path path : Path.values()) {
+            RegionType.ConnectionType connectionType = RegionSystem.INSTANCE.get(minPoint.add(path.checkX, 0, path.checkZ).toLocation((World) null)).getType().getConnectionType();
+            File schem = path.function.apply(connectionType);
+            if (schem.exists()) {
+                paste(schem, minPoint.add(path.pasteX, 0, path.pasteZ), path.rotate);
+            }
+        }
+
+        for (PathCorner corner : PathCorner.values()) {
+            RegionType.ConnectionType connectionType1 = RegionSystem.INSTANCE.get(minPoint.add(corner.check1.checkX, 0, corner.check1.checkZ).toLocation((World) null)).getType().getConnectionType();
+            RegionType.ConnectionType connectionType2 = RegionSystem.INSTANCE.get(minPoint.add(corner.check2.checkX, 0, corner.check2.checkZ).toLocation((World) null)).getType().getConnectionType();
+            RegionType.ConnectionType connectionTypeCorner = RegionSystem.INSTANCE.get(minPoint.add(corner.check1.checkX + corner.check2.checkX, 0, corner.check1.checkZ + corner.check2.checkZ).toLocation((World) null)).getType().getConnectionType();
+            File schem = corner.function.apply(connectionType1, connectionType2, connectionTypeCorner);
+            if (schem.exists()) {
+                System.out.println(connectionType1 + " " + connectionType2 + " " + connectionTypeCorner + " " + schem);
+                paste(schem, minPoint.add(corner.pasteX, 0, corner.pasteZ), corner.rotate);
+            } else {
+                System.out.println(connectionType1 + " " + connectionType2 + " " + connectionTypeCorner + " " + PATH_DIR.getAbsolutePath() + "/PathCornerUnknown.schem");
+                paste(new File(PATH_DIR, "PathCornerUnknown.schem"), minPoint.add(corner.pasteX, 0, corner.pasteZ), corner.rotate);
+            }
+        }
+    }
+
+    private void paste(File file, Point minPoint, int rotate) {
+        Clipboard clipboard = FlatteningWrapper.impl.loadSchematic(file);
+        BlockVector3 offset = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin());
+        BlockVector3 to = minPoint.toBlockVector3().subtract(offset);
+        clipboard.paste(BukkitAdapter.adapt(Bukkit.getWorlds().get(0)), to, false, true, new AffineTransform().rotateY(rotate));
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/path/PathRegion.java

@@ -0,0 +1,109 @@
+/*
+ * 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.dynamic.path;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionHistory;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.*;
+import de.steamwar.bausystem.region.dynamic.spawn.SpawnAreaTile;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class PathRegion extends DynamicRegion {
+
+    private static final File SECTIONS_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections");
+    private static final File RESET_FILE = new File(SECTIONS_DIR, "path/Path.schem"); // Temp
+
+    private DefaultFlagStorage flagStorage = new NonNormalFlagStorage();
+    private final Area area;
+
+    public PathRegion(int minX, int minZ) {
+        super(minX, minZ);
+        RegionDataRepository.loadFlagStorage(this, flagStorage);
+        if (minX >= -28 && minX <= 10 && minZ >= -28 && minZ <= 10) {
+            area = new SpawnAreaTile(minX, minZ, VariantSelector.File(RESET_FILE), this);
+        } else {
+            area = new PathAreaTile(minX, minZ, this);
+        }
+    }
+
+    public PathRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        RegionDataRepository.loadFlagStorage(this, flagStorage);
+        if (minX >= -28 && minX <= 10 && minZ >= -28 && minZ <= 10) {
+            area = new SpawnAreaTile(minX, minZ, VariantSelector.File(RESET_FILE), this);
+        } else {
+            area = new PathAreaTile(minX, minZ, this);
+        }
+    }
+
+    @Override
+    public void update(DynamicRegion updateFrom) {
+        if (area instanceof PathAreaTile) {
+            area.reset(null, false);
+        }
+    }
+
+    @Override
+    public void setFlags(DefaultFlagStorage flags) {
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        if (area instanceof SpawnAreaTile) {
+            return RegionType.SPAWN_EXTENSION;
+        } else {
+            return RegionType.PATH;
+        }
+    }
+
+    @Override
+    public @NonNull DefaultFlagStorage getFlags() {
+        return flagStorage;
+    }
+
+    @Override
+    public @NonNull Area getArea() {
+        return area;
+    }
+
+    @Override
+    public @NonNull Area getBuildArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull Area getTestblockArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull GameModeConfig getGameModeConfig() {
+        return GameModeConfig.EMPTY;
+    }
+
+    @Override
+    public @NonNull RegionHistory getHistory() {
+        return RegionHistory.EMPTY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/spawn/SpawnAreaTile.java

@@ -0,0 +1,78 @@
+/*
+ * 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.dynamic.spawn;
+
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import lombok.NonNull;
+
+import javax.annotation.Nullable;
+import java.io.File;
+
+public class SpawnAreaTile implements Region.Area {
+
+    private final int minX;
+    private final int minZ;
+    private final VariantSelector variantSelector;
+    private final Point minPoint;
+    private final Point maxPoint;
+    private final Point copyPoint;
+    private final Region region;
+
+    public SpawnAreaTile(int minX, int minZ, VariantSelector variantSelector, Region region) {
+        this.minX = minX;
+        this.minZ = minZ;
+        this.variantSelector = variantSelector;
+
+        minPoint = new Point(minX, 0, minZ);
+        maxPoint = new Point(minX + 18, 255, minZ + 18);
+        copyPoint = new Point(minX + 9, 0, minZ + 9);
+
+        this.region = region;
+    }
+
+    @Override
+    public @NonNull Point getMinPoint(boolean extension) {
+        return minPoint;
+    }
+
+    @Override
+    public @NonNull Point getMaxPoint(boolean extension) {
+        return maxPoint;
+    }
+
+    @Override
+    public @NonNull Point getCopyPoint() {
+        return copyPoint;
+    }
+
+    @Nullable
+    @Override
+    public File getResetFile() {
+        return variantSelector.selectVariant(minX, minZ).orElseThrow();
+    }
+
+    @Override
+    public void reset(PasteBuilder pasteBuilder, boolean extension) {
+        SpawnResetter.reset(region);
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/spawn/SpawnPathRegion.java

@@ -0,0 +1,110 @@
+/*
+ * 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.dynamic.spawn;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionHistory;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.*;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class SpawnPathRegion extends DynamicRegion {
+
+    private static final File SECTIONS_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections");
+    private static final File RESET_FILE_NORTH = new File(SECTIONS_DIR, "spawn/SpawnNorth.schem");
+    private static final File RESET_FILE_SOUTH = new File(SECTIONS_DIR, "spawn/SpawnSouth.schem");
+    private static final File RESET_FILE_WEST = new File(SECTIONS_DIR, "spawn/SpawnWest.schem");
+    private static final File RESET_FILE_EAST = new File(SECTIONS_DIR, "spawn/SpawnEast.schem");
+
+    private DefaultFlagStorage flagStorage = new NonNormalFlagStorage();
+    private final Area area;
+
+    public SpawnPathRegion(int minX, int minZ) {
+        super(minX, minZ);
+        RegionDataRepository.loadFlagStorage(this, flagStorage);
+        area = new SpawnAreaTile(minX, minZ, getResetFile(minX, minZ), this);
+    }
+
+    public SpawnPathRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        RegionDataRepository.loadFlagStorage(this, flagStorage);
+        area = new SpawnAreaTile(minX, minZ, getResetFile(minX, minZ), this);
+    }
+
+    private static VariantSelector getResetFile(int minX, int minZ) {
+        if (minX == -28) {
+            return VariantSelector.File(RESET_FILE_WEST);
+        } else if (minX == 10) {
+            return VariantSelector.File(RESET_FILE_EAST);
+        } else if (minZ == -28) {
+            return VariantSelector.File(RESET_FILE_NORTH);
+        } else if (minZ == 10) {
+            return VariantSelector.File(RESET_FILE_SOUTH);
+        }
+        throw new IllegalArgumentException("Invalid minX: " + minX + ", minZ: " + minZ);
+    }
+
+    @Override
+    public void update(DynamicRegion updateFrom) {
+        // TODO: Implement
+    }
+
+    @Override
+    public void setFlags(DefaultFlagStorage flags) {
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.SPAWN_PATH;
+    }
+
+    @Override
+    public @NonNull DefaultFlagStorage getFlags() {
+        return flagStorage;
+    }
+
+    @Override
+    public @NonNull Area getArea() {
+        return area;
+    }
+
+    @Override
+    public @NonNull Area getBuildArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull Area getTestblockArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull GameModeConfig getGameModeConfig() {
+        return GameModeConfig.EMPTY;
+    }
+
+    @Override
+    public @NonNull RegionHistory getHistory() {
+        return RegionHistory.EMPTY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/spawn/SpawnRegion.java

@@ -0,0 +1,94 @@
+/*
+ * 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.dynamic.spawn;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionHistory;
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.*;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class SpawnRegion extends DynamicRegion {
+
+    private static final File SECTIONS_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections");
+    private static final File RESET_FILE = new File(SECTIONS_DIR, "spawn/SpawnMiddle.schem");
+
+    private DefaultFlagStorage flagStorage = new NonNormalFlagStorage();
+    private final Area area;
+
+    public SpawnRegion(int minX, int minZ) {
+        super(minX, minZ);
+        RegionDataRepository.loadFlagStorage(this, flagStorage);
+        area = new SpawnAreaTile(minX, minZ, VariantSelector.File(RESET_FILE), this);
+    }
+
+    public SpawnRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        RegionDataRepository.loadFlagStorage(this, flagStorage);
+        area = new SpawnAreaTile(minX, minZ, VariantSelector.File(RESET_FILE), this);
+    }
+
+    @Override
+    public void update(DynamicRegion updateFrom) {
+        SpawnResetter.reset(null);
+    }
+
+    @Override
+    public void setFlags(DefaultFlagStorage flags) {
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.SPAWN;
+    }
+
+    @Override
+    public @NonNull DefaultFlagStorage getFlags() {
+        return flagStorage;
+    }
+
+    @Override
+    public @NonNull Area getArea() {
+        return area;
+    }
+
+    @Override
+    public @NonNull Area getBuildArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull Area getTestblockArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull GameModeConfig getGameModeConfig() {
+        return GameModeConfig.EMPTY;
+    }
+
+    @Override
+    public @NonNull RegionHistory getHistory() {
+        return RegionHistory.EMPTY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/spawn/SpawnResetter.java

@@ -0,0 +1,99 @@
+/*
+ * 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.dynamic.spawn;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.extent.clipboard.Clipboard;
+import com.sk89q.worldedit.math.BlockVector3;
+import de.steamwar.bausystem.region.*;
+import de.steamwar.bausystem.utils.FlatteningWrapper;
+import lombok.experimental.UtilityClass;
+import org.bukkit.Bukkit;
+import org.bukkit.Location;
+
+import java.io.File;
+import java.util.List;
+import java.util.stream.Collectors;
+
+@UtilityClass
+public class SpawnResetter {
+
+    private static final File SECTIONS_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections");
+    private static final File RESET_FILE = new File(SECTIONS_DIR, "spawn/SpawnBig.schem");
+
+    public static final Location BIG_WORLD_SPAWN = new Location(Bukkit.getWorlds().get(0), 0.5, 26, 0.5);
+    public static final Location SMALL_WORLD_SPAWN = new Location(Bukkit.getWorlds().get(0), 0.5, 32, 0.5);
+
+    private static final Location LOCATION = new Location(null, 0, 0, 0);
+
+    public boolean isBigSpawn() {
+        Region spawnRegion = DynamicRegionSystem.INSTANCE.get(LOCATION);
+        List<Region> neighbours = DynamicRegionSystem.INSTANCE.getNeighbours(spawnRegion)
+                .filter(r -> r.getType() == RegionType.PATH || r.getType() == RegionType.SPAWN_EXTENSION || r.getType() == RegionType.SPAWN_PATH)
+                .collect(Collectors.toList());
+        return neighbours.size() == 8;
+    }
+
+    public void reset(Region region) {
+        Region spawnRegion = DynamicRegionSystem.INSTANCE.get(LOCATION);
+        List<Region> neighbours = DynamicRegionSystem.INSTANCE.getNeighbours(spawnRegion)
+                .filter(r -> r.getType() == RegionType.PATH || r.getType() == RegionType.SPAWN_EXTENSION || r.getType() == RegionType.SPAWN_PATH)
+                .collect(Collectors.toList());
+
+        if (neighbours.size() == 8) {
+            Bukkit.getWorlds().get(0).setSpawnLocation(BIG_WORLD_SPAWN);
+
+            Region.Area area = spawnRegion.getArea();
+            Point minPoint = area.getMinPoint(false).subtract(19, 0, 19);
+            Clipboard clipboard = FlatteningWrapper.impl.loadSchematic(RESET_FILE);
+            BlockVector3 offset = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin());
+            BlockVector3 to = minPoint.toBlockVector3().subtract(offset);
+            clipboard.paste(BukkitAdapter.adapt(Bukkit.getWorlds().get(0)), to);
+
+            if (spawnRegion != region) {
+                RegionUtils.message(spawnRegion, "REGION_RESET_RESETED");
+            }
+            neighbours.forEach(r -> {
+                if (r != region) {
+                    RegionUtils.message(r, "REGION_RESET_RESETED");
+                }
+            });
+            return;
+        } else {
+            Bukkit.getWorlds().get(0).setSpawnLocation(SMALL_WORLD_SPAWN);
+        }
+
+        internalReset(spawnRegion, spawnRegion != region);
+        DynamicRegionSystem.INSTANCE.getNeighbours(spawnRegion)
+                .forEach(r -> internalReset(r, r != region));
+    }
+
+    private void internalReset(Region region, boolean message) {
+        Region.Area area = region.getArea();
+        Point minPoint = area.getMinPoint(false);
+        Clipboard clipboard = FlatteningWrapper.impl.loadSchematic(area.getResetFile());
+        BlockVector3 offset = clipboard.getRegion().getMinimumPoint().subtract(clipboard.getOrigin());
+        BlockVector3 to = minPoint.toBlockVector3().subtract(offset);
+        clipboard.paste(BukkitAdapter.adapt(Bukkit.getWorlds().get(0)), to);
+        if (message) {
+            RegionUtils.message(region, "REGION_RESET_RESETED");
+        }
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/special/DrySpecialRegion.java

@@ -0,0 +1,54 @@
+/*
+ * 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.dynamic.special;
+
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class DrySpecialRegion extends SpecialRegion {
+
+    private static final File SECTIONS_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections");
+    private static final File RESET_FILE = new File(SECTIONS_DIR, "special/DryRegion.schem");
+
+    public DrySpecialRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new SpecialAreaTile(minX, minZ, VariantSelector.File(RESET_FILE));
+    }
+
+    public DrySpecialRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new SpecialAreaTile(minX, minZ, VariantSelector.File(RESET_FILE));
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.DRY_SPECIAL;
+    }
+
+    @Override
+    public int getFloorLevel() {
+        return 32;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/special/SpecialAreaTile.java

@@ -0,0 +1,78 @@
+/*
+ * 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.dynamic.special;
+
+import de.steamwar.bausystem.region.Point;
+import de.steamwar.bausystem.region.Region;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import de.steamwar.bausystem.utils.PasteBuilder;
+import lombok.NonNull;
+
+import javax.annotation.Nullable;
+import java.io.File;
+
+public class SpecialAreaTile implements Region.Area {
+
+    private final int minX;
+    private final int minZ;
+    private final VariantSelector variantSelector;
+
+    private final Point minPoint;
+    private final Point maxPoint;
+    private final Point copyPoint;
+
+    public SpecialAreaTile(int minX, int minZ, VariantSelector variantSelector) {
+        this.minX = minX;
+        this.minZ = minZ;
+        this.variantSelector = variantSelector;
+
+        minPoint = new Point(minX, 0, minZ);
+        maxPoint = new Point(minX + 18, 255, minZ + 18);
+        copyPoint = new Point(minX + 9, 0, minZ + 9);
+    }
+
+    @Override
+    public @NonNull Point getMinPoint(boolean extension) {
+        return minPoint;
+    }
+
+    @Override
+    public @NonNull Point getMaxPoint(boolean extension) {
+        return maxPoint;
+    }
+
+    @Override
+    public @NonNull Point getCopyPoint() {
+        return copyPoint;
+    }
+
+    @Nullable
+    @Override
+    public File getResetFile() {
+        return variantSelector.selectVariant(minX, minZ).orElseThrow();
+    }
+
+    @Override
+    public void reset(PasteBuilder pasteBuilder, boolean extension) {
+        pasteBuilder.minPoint(minPoint)
+                .maxPoint(maxPoint)
+                .run();
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/special/SpecialFlagStorage.java

@@ -0,0 +1,47 @@
+/*
+ * 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.dynamic.special;
+
+import de.steamwar.bausystem.region.DynamicRegionSystem;
+import de.steamwar.bausystem.region.dynamic.DynamicRegion;
+import de.steamwar.bausystem.region.dynamic.normal.NormalFlagStorage;
+import de.steamwar.bausystem.region.flags.Flag;
+import de.steamwar.bausystem.region.flags.TNTMode;
+import lombok.NonNull;
+
+public class SpecialFlagStorage extends NormalFlagStorage {
+
+    private DynamicRegion region;
+
+    public SpecialFlagStorage(DynamicRegion region) {
+        this.region = region;
+        flagMap.put(Flag.TNT, TNTMode.DENY);
+    }
+
+    @Override
+    public <T extends Enum<T> & Flag.Value<T>> boolean set(@NonNull Flag<T> flag, @NonNull T value) {
+        boolean result = super.set(flag, value);
+        DynamicRegionSystem.INSTANCE.getConnectedRegions(region).forEach(other -> {
+            other.getFlags().getBackedMap().put(flag, value);
+            other.getFlags().save();
+        });
+        return result;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/special/SpecialRegion.java

@@ -0,0 +1,77 @@
+/*
+ * 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.dynamic.special;
+
+import de.steamwar.bausystem.region.GameModeConfig;
+import de.steamwar.bausystem.region.RegionHistory;
+import de.steamwar.bausystem.region.dynamic.DefaultFlagStorage;
+import de.steamwar.bausystem.region.dynamic.DynamicRegion;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.RegionDataRepository;
+import lombok.Getter;
+import lombok.NonNull;
+
+public abstract class SpecialRegion extends DynamicRegion {
+
+    @Getter
+    private DefaultFlagStorage flags = new SpecialFlagStorage(this);
+
+    @Getter
+    protected SpecialAreaTile area;
+
+    protected SpecialRegion(int minX, int minZ) {
+        super(minX, minZ);
+        RegionDataRepository.loadFlagStorage(this, flags);
+    }
+
+    protected SpecialRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        RegionDataRepository.loadFlagStorage(this, flags);
+    }
+
+    @Override
+    public void update(DynamicRegion updateFrom) {
+    }
+
+    @Override
+    public void setFlags(DefaultFlagStorage flags) {
+        this.flags = flags;
+    }
+
+    @Override
+    public @NonNull Area getBuildArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull Area getTestblockArea() {
+        return Area.EMPTY;
+    }
+
+    @Override
+    public @NonNull GameModeConfig getGameModeConfig() {
+        return GameModeConfig.EMPTY;
+    }
+
+    @Override
+    public @NonNull RegionHistory getHistory() {
+        return RegionHistory.EMPTY;
+    }
+}

BauSystem/BauSystem_RegionDynamic/src/de/steamwar/bausystem/region/dynamic/special/WetSpecialRegion.java

@@ -0,0 +1,49 @@
+/*
+ * 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.dynamic.special;
+
+import de.steamwar.bausystem.region.RegionType;
+import de.steamwar.bausystem.region.dynamic.RegionConstructorData;
+import de.steamwar.bausystem.region.dynamic.VariantSelector;
+import lombok.NonNull;
+import org.bukkit.Bukkit;
+
+import java.io.File;
+
+public class WetSpecialRegion extends SpecialRegion {
+
+    private static final File SECTIONS_DIR = new File(Bukkit.getWorlds().get(0).getWorldFolder(), "sections");
+    private static final File RESET_FILE = new File(SECTIONS_DIR, "special/WetRegion.schem");
+
+    public WetSpecialRegion(int minX, int minZ) {
+        super(minX, minZ);
+        area = new SpecialAreaTile(minX, minZ, VariantSelector.File(RESET_FILE));
+    }
+
+    public WetSpecialRegion(RegionConstructorData regionConstructorData) {
+        super(regionConstructorData);
+        area = new SpecialAreaTile(minX, minZ, VariantSelector.File(RESET_FILE));
+    }
+
+    @Override
+    public @NonNull RegionType getType() {
+        return RegionType.WET_SPECIAL;
+    }
+}

BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/region/fixed/FixedFlagStorage.java

@@ -26,11 +26,13 @@ import de.steamwar.bausystem.region.flags.Flag;
 import de.steamwar.bausystem.worlddata.WorldData;
 import de.steamwar.core.Core;
 import lombok.NonNull;
+import lombok.ToString;
 import yapion.hierarchy.types.YAPIONObject;
 
 import java.util.HashMap;
 import java.util.Map;
 
+@ToString
 public class FixedFlagStorage implements FlagStorage {
 
     private Map<Flag<?>, Flag.Value<?>> flagMap = new HashMap<>();
@@ -82,20 +84,8 @@ public class FixedFlagStorage implements FlagStorage {
         return FlagOptional.of(flag, (T) flagMap.get(flag));
     }
 
-    @Override
-    public void clear() {
-        flagMap.clear();
-    }
-
     @Override
     public Map<Flag<?>, Flag.Value<?>> getBackedMap() {
         return flagMap;
     }
-
-    @Override
-    public String toString() {
-        return "FixedFlagStorage{" +
-                "flagMap=" + flagMap +
-                '}';
-    }
 }

BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/region/fixed/FixedGlobalFlagStorage.java

@@ -89,11 +89,6 @@ public class FixedGlobalFlagStorage implements FlagStorage {
         return FlagOptional.of(flag, (T) flagMap.get(flag));
     }
 
-    @Override
-    public void clear() {
-        flagMap.clear();
-    }
-
     @Override
     public Map<Flag<?>, Flag.Value<?>> getBackedMap() {
         return flagMap;

BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/region/fixed/FixedGlobalRegion.java

@@ -90,8 +90,6 @@ public final class FixedGlobalRegion implements Region {
         }
     };
 
-    private static final GameModeConfig GLOBAL_CONFIG = new GameModeConfig(null);
-
     private FixedGlobalRegion() {
     }
 
@@ -127,7 +125,7 @@ public final class FixedGlobalRegion implements Region {
 
     @Override
     public @NonNull GameModeConfig getGameModeConfig() {
-        return GLOBAL_CONFIG;
+        return GameModeConfig.EMPTY;
     }
 
     @Override

BauSystem/BauSystem_RegionFixed/src/de/steamwar/bausystem/region/fixed/FixedRegion.java

@@ -137,6 +137,11 @@ public class FixedRegion implements Region {
         public void delete() {
             file.delete();
         }
+
+        @Override
+        public long getCreationTime() {
+            return file.lastModified();
+        }
     }
 
     public FixedRegion(String name, FixedFlagStorage flagStorage, Prototype prototype, YAPIONObject regionConfig, YAPIONObject regionData) {

BauSystem/build.gradle.kts

@@ -28,6 +28,7 @@ tasks.build {
 
 dependencies {
     implementation(project(":BauSystem:BauSystem_RegionFixed"))
+    implementation(project(":BauSystem:BauSystem_RegionDynamic"))
     implementation(project(":BauSystem:BauSystem_Main"))
     implementation(project(":BauSystem:BauSystem_15"))
     implementation(project(":BauSystem:BauSystem_18"))

SpigotCore/SpigotCore_Main/src/de/steamwar/Reflection.java

@@ -157,23 +157,7 @@ public final class Reflection {
 			} else if(MAJOR_VERSION < 21 || MINOR_VERSION < 4) {
 				return Class.forName(spigotClassnames.getOrDefault(name, name));
 			} else {
-				Class<?> clazz = null;
-				try {
-					clazz = Class.forName(name);
-				} catch (ClassNotFoundException e) {}
-				if (clazz != null && clazz.getName().equals(name)) {
-					return clazz;
-				}
-
-				try {
-					return Core.class.getClassLoader().getParent().loadClass(name);
-				} catch (ClassNotFoundException e) {
-					if (clazz == null) {
-						throw e;
-					}
-
-					return clazz;
-				}
+				return Class.forName(name);
 			}
 		} catch (ClassNotFoundException e) {
 			throw new IllegalArgumentException("Cannot find " + name, e);

settings.gradle.kts

@@ -178,6 +178,7 @@ include(
     "BauSystem:BauSystem_20",
     "BauSystem:BauSystem_21",
     "BauSystem:BauSystem_Main",
+    "BauSystem:BauSystem_RegionDynamic",
     "BauSystem:BauSystem_RegionFixed"
 )