Remove debug output

Reviewed-on: SteamWar/SteamWar#478

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

@@ -0,0 +1,41 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.world;
+
+import de.steamwar.linkage.Linked;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.scoreboard.Scoreboard;
+import org.bukkit.scoreboard.Team;
+
+@Linked
+public class AntiPlayerCollision implements Listener {
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void onPlayerJoin(PlayerJoinEvent event) {
+        Scoreboard board = event.getPlayer().getScoreboard();
+        Team team = board.getTeam("players");
+        if (team == null) team = board.registerNewTeam("players");
+        team.setOption(Team.Option.COLLISION_RULE, Team.OptionStatus.NEVER);
+        team.addPlayer(event.getPlayer());
+    }
+}

CommonCore/SQL/build.gradle.kts

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

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

@@ -688,13 +688,6 @@ public final class GameModeConfig<M, W> {
          */
         public final int MaxBlocks;
 
-        /**
-         * Maximal amount of items per dispenser
-         *
-         * @implSpec {@code 128} by default
-         */
-        public final int MaxDispenserItems;
-
         /**
          * Maximal blast resistance for the blocks
          *
@@ -710,10 +703,12 @@ public final class GameModeConfig<M, W> {
         public final double MaxDesignBlastResistance;
 
         /**
-         * List of limited material (combinations)<br/>
-         * List contains tags Amount (integer) and Materials (List of material names in Spigot 1.12 AND Spigot 1.15 format)
+         * List of limited block materials
+         *
+         * @implSpec {@link SQLWrapper#getInventoryMaterials)} are all disallowed by default to have any content but are unlimited in number.
+         * @implSpec Any Block that has more Blast Resistance than {@link #MaxBlastResistance} will be defaulted to 0.
          */
-        public final Map<Set<M>, Integer> Limited;
+        public final List<BlockRule<M>> Limited;
 
         private SchematicConfig(YMLWrapper<M, ?> loader) {
             loaded = loader.canLoad();
@@ -731,32 +726,140 @@ public final class GameModeConfig<M, W> {
             IgnorePublicOnly = loader.getBoolean("IgnorePublicOnly", false);
             UnlimitedPrepare = loader.getBoolean("UnlimitedPrepare", false);
             MaxBlocks = loader.getInt("MaxBlocks", 0);
-            MaxDispenserItems = loader.getInt("MaxDispenserItems", 128);
             MaxBlastResistance = loader.getDouble("MaxBlastResistance", Double.MAX_VALUE);
             MaxDesignBlastResistance = loader.getDouble("MaxDesignBlastResistance", MaxBlastResistance);
 
-            Map<Set<M>, Integer> Limited = new HashMap<>();
-            for (Map<?, ?> entry : loader.getMapList("Limited")) {
-                int amount = (Integer) entry.get("Amount");
-                Set<String> materials = new HashSet<>((List<String>) entry.get("Materials"));
-                if (amount == 0) {
-                    materials.forEach(material -> {
-                        Limited.put(Collections.singleton(loader.materialMapper.apply(material.toUpperCase())), 0);
-                    });
-                } else {
-                    Limited.put(Collections.unmodifiableSet(materials.stream().map(String::toUpperCase).map(loader.materialMapper).collect(Collectors.toSet())), amount);
-                }
+            List<BlockRule<M>> limited = new ArrayList<>();
+            Set<M> blocks = new HashSet<>();
+            for (YMLWrapper<M, ?> limitedLoader : loader.withAsList("Limited")) {
+                BlockRule<M> blockRule = new BlockRule<>(limitedLoader);
+                blocks.addAll(blockRule.Materials);
+                limited.add(blockRule);
             }
-            SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance).forEach(material -> {
-                if (Limited.entrySet().stream().anyMatch(entry -> entry.getKey().contains(material))) return;
-                Limited.put(Collections.singleton((M) material), 0);
-            });
-            this.Limited = Collections.unmodifiableMap(Limited);
+            for (M material : (List<M>) SQLWrapper.impl.getMaterialWithGreaterBlastResistance(MaxBlastResistance)) {
+                if (material == null || !blocks.add(material)) continue;
+                limited.add(new BlockRule<>(material, 0));
+            }
+            for (M material : (Set<M>) SQLWrapper.impl.getInventoryMaterials()) {
+                if (material == null || !blocks.add(material)) continue;
+                limited.add(new BlockRule<>(material, Integer.MAX_VALUE));
+            }
+            this.Limited = Collections.unmodifiableList(limited);
 
             this.ReplacementsWithoutBlockUpdates = loader.getMap("ReplacementsWithoutBlockUpdates", loader.materialMapper, loader.materialMapper);
             this.ReplacementsWithBlockUpdates = loader.getMap("ReplacementsWithBlockUpdates", loader.materialMapper, loader.materialMapper);
         }
 
+        public int getMaxCount(M material) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .mapToInt(rule -> rule.Amount)
+                    .max()
+                    .orElse(Integer.MAX_VALUE);
+        }
+
+        public boolean isInventory(M material) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .anyMatch(rule -> rule.Content.loaded);
+        }
+
+        public Integer getItemAmount(M material, M item) {
+            return Limited.stream()
+                    .filter(rule -> rule.Materials.contains(material))
+                    .filter(rule -> rule.Content.Items.contains(item))
+                    .mapToInt(rule -> rule.Content.Amount)
+                    .max()
+                    .orElse(0);
+        }
+
+        @ToString
+        public static final class BlockRule<M> {
+
+            /**
+             * The block materials this rule applies to
+             */
+            public final Set<M> Materials;
+
+            /**
+             * Maximal amount of Blocks allowed in the schematic
+             *
+             * @implSpec {@code 0} by default
+             */
+            public final int Amount;
+
+            /**
+             * The item content filter for Blocks
+             *
+             * @implSpec no Items with {@code Amount 0} (denies any item) by default
+             */
+            public final Content<M> Content;
+
+            /**
+             * Resolves one {@code Materials} entry to the concrete materials it denotes: {@code storage}
+             * for {@link SQLWrapper#getStorageMaterials()}, {@code all} for
+             * {@link SQLWrapper#getInventoryMaterials()}, or the material itself otherwise.
+             */
+            private Set<M> expandInventoryGroup(YMLWrapper<M, ?> loader, String name) {
+                switch (name.toUpperCase()) {
+                    case "STORAGE":
+                        return (Set<M>) SQLWrapper.impl.getStorageMaterials();
+                    case "INVENTORY":
+                        return (Set<M>) SQLWrapper.impl.getInventoryMaterials();
+                    default:
+                        M material = loader.materialMapper.apply(name.toUpperCase());
+                        return material != null ? Collections.singleton(material) : Collections.emptySet();
+                }
+            }
+
+            private BlockRule(YMLWrapper<M, ?> loader) {
+                Set<M> blocks = loader.getStringList("Materials")
+                        .stream()
+                        .flatMap(value -> expandInventoryGroup(loader, value).stream())
+                        .collect(Collectors.toSet());
+                Materials = Collections.unmodifiableSet(blocks);
+                Amount = loader.getInt("Amount", 0);
+                Content = new Content<>(loader.with("Content"));
+            }
+
+            private BlockRule(M block, int amount) {
+                Materials = Collections.singleton(block);
+                Amount = amount;
+                Content = new Content<>();
+            }
+
+            @ToString
+            public static final class Content<M> {
+
+                public final boolean loaded;
+
+                /**
+                 * Items allowed by this rule
+                 */
+                public final Set<M> Items;
+
+                /**
+                 * Maximal amount of an allowed item per single block instance
+                 *
+                 * @implSpec {@code 0} by default
+                 */
+                public final int Amount;
+
+                private Content(YMLWrapper<M, ?> loader) {
+                    loaded = loader.canLoad();
+                    List<M> items = loader.getMaterialList("Items");
+                    Items = Collections.unmodifiableSet(new HashSet<>(items));
+                    Amount = loader.getInt("Amount", 0);
+                }
+
+                private Content() {
+                    loaded = false;
+                    Items = new HashSet<>();
+                    Amount = 0;
+                }
+            }
+        }
+
         @ToString
         public static final class SizeConfig {
 

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

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

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

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

FightSystem/FightSystem_Core/src/config.yml

@@ -107,15 +107,23 @@ Schematic:
   UnlimitedPrepare: false # defaults to false if missing
   # Maximal amount of blocks allowed in the schematic
   MaxBlocks: 0 # defaults to 0 (ignored) if missing
-  # Maximal amount of items per dispenser
-  MaxDispenserItems: 128 # defaults to 128 if missing
   # Maximal blast resistance for the design blocks
   MaxDesignBlastResistance: 100000000 # defaults to Double.MAX_VALUE if missing
-  # List of limited material (combinations)
-  # List contains tags Amount (integer) and Materials (List of material names in Spigot 1.12 AND Spigot 1.15 format)
+  # List of limited block materials
+  # InventoryMaterials are all disallowed by default to have any content but are unlimited in number
+  # Any Block that has more Blast Resistance than MaxBlastResistance will be defaulted to 0.
   Limited:
-    - Materials: [ ]
-      Amount: 0
+    - Blocks: [ DISPENSER ]
+      MaxCount: 64
+    - Blocks: [ DISPENSER ]
+      MaxCount: 16
+      Content:
+        Items: [ ARROW, FIRE_CHARGE ]
+        Amount: 128
+    - Blocks: [ storage ]
+      Content:
+        Items: [ TNT ]
+        Amount: 1728
 
 # The name of the game mode presented to the players
 GameName: WarGear # defaults to WarGear if missing

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

@@ -47,7 +47,7 @@ public class Check implements Listener {
 
     private boolean checkPermission(SteamwarUser user, SchematicNode schematic) {
         GameModeConfig<Object, String> gameModeConfig = GameModeConfig.getAll().stream()
-                .filter(gmc -> gmc.Schematic.Type != null && gmc.Schematic.Type.equals(schematic.getSchemtype()))
+                .filter(gmc -> gmc.Schematic.Type != null && gmc.Schematic.Type.checkType() != null && schematic.getSchemtype().name().equals(gmc.Schematic.Type.checkType().name()))
                 .findFirst()
                 .orElse(null);
         if (gameModeConfig == null) gameModeConfig = GameModeConfig.getDefaults();

MissileWars/src/de/steamwar/misslewars/items/CustomItem.java

@@ -69,6 +69,7 @@ public class CustomItem extends SpecialItem {
         }
         for (File itemFile : Objects.requireNonNull(itemsFolder.listFiles())) {
             if (!itemFile.canRead() || !itemFile.isFile()) continue;
+            if (!itemFile.getName().endsWith(".json")) continue;
             try {
                 JsonObject jsonObject = new JsonParser().parse(new FileReader(itemFile)).getAsJsonObject();
                 new CustomItem(new ScriptedItem(jsonObject));

MissileWars/src/de/steamwar/misslewars/scripts/implemented/LaunchScript.java

@@ -25,6 +25,7 @@ import de.steamwar.misslewars.scripts.RunnableScriptEvent;
 import de.steamwar.misslewars.scripts.ScriptedItem;
 import de.steamwar.misslewars.scripts.utils.EntityUtils;
 import de.steamwar.misslewars.scripts.utils.EntityUtils.ScriptShortcut;
+import org.bukkit.Material;
 import org.bukkit.entity.Projectile;
 
 public class LaunchScript implements RunnableScript {

MissileWars/src/de/steamwar/misslewars/scripts/utils/EntityUtils.java

@@ -75,6 +75,11 @@ public class EntityUtils {
                 });
             case "arrow":
                 return new ScriptShortcut<>(Arrow.class, (jsonObject, entity, runnableScriptEvent) -> setProjectileOptions(entity, jsonObject));
+            case "windcharge":
+                return new ScriptShortcut<>(WindCharge.class, (jsonObject, entity, runnableScriptEvent) -> {
+                    setFireballOptions(entity, jsonObject);
+                    entity.setDirection(runnableScriptEvent.getLocation().getDirection());
+                });
         }
         return null;
     }

SchematicSystem/src/SchematicSystem.properties

@@ -269,7 +269,7 @@ AUTO_CHECKER_RESULT_DEFUNCT_NBT = §7Defunct NBT: §7[{0}, {1}, {2}]
 AUTO_CHECKER_RESULT_DESIGN_BLOCK = §7{0} in Design: [{1}, {2}, {3}]
 AUTO_CHECKER_RESULT_ENTITY = §7Entity: §7[{0}, {1}, {2}]
 AUTO_CHECKER_RESULT_RECORD = §7Record: §c[{0}, {1}, {2}]
-AUTO_CHECKER_RESULT_TOO_MANY_DISPENSER_ITEMS = §7Dispenser: §c[{0}, {1}, {2}]§7, §c{3} §7items, Max: §e{4}
+AUTO_CHECKER_RESULT_TOO_MANY_INVENTORY_ITEMS = §7{6}: §c[{0}, {1}, {2}]§7, §c{3}x {5}§7, Max: §e{4}
 AUTO_CHECKER_RESULT_FORBIDDEN_ITEM_NBT = §7Forbidden Item NBT: [{0}, {1}, {2}] -> §c{3}
 AUTO_CHECKER_RESULT_TELEPORT_HERE = §7Teleport to block
 AUTO_CHECKER_RESULT_AFTER_DEADLINE = §cThe deadline has expired: {0}

SchematicSystem/src/SchematicSystem_de.properties

@@ -248,7 +248,7 @@ AUTO_CHECKER_RESULT_FORBIDDEN_ITEM = §7Verbotener gegenstand: [{0}, {1}, {2}] -
 AUTO_CHECKER_RESULT_DEFUNCT_NBT = §7Keine NBT-Daten: §c[{0}, {1}, {2}]
 AUTO_CHECKER_RESULT_DESIGN_BLOCK = §7{0} im Design: [{1}, {2}, {3}]
 AUTO_CHECKER_RESULT_RECORD = §7Schallplatte: §c[{0}, {1}, {2}]
-AUTO_CHECKER_RESULT_TOO_MANY_DISPENSER_ITEMS = §7Dispenser: §c[{0}, {1}, {2}]§7, §c{3} §7gegenstände, Max: §e{4}
+AUTO_CHECKER_RESULT_TOO_MANY_INVENTORY_ITEMS = §7{6}: §c[{0}, {1}, {2}]§7, §c{3}x {5}§7, Max: §e{4}
 AUTO_CHECKER_RESULT_FORBIDDEN_ITEM_NBT = §7Verbotene NBT-Daten: [{0}, {1}, {2}] -> §c{3}
 AUTO_CHECKER_RESULT_TELEPORT_HERE = §7Zum block teleportieren
 AUTO_CHECKER_RESULT_AFTER_DEADLINE = §cDer einsendeschluss ist bereits vorbei: {0}

SchematicSystem/src/de/steamwar/schematicsystem/autocheck/AutoChecker.java

@@ -75,9 +75,9 @@ public class AutoChecker {
 
                     BlockPos pos = new BlockPos(x, y, z);
 
-                    if (AutoCheckerItems.impl.getInventoryMaterials().contains(material)) {
+                    if (type.Schematic.isInventory(material)) {
                         checkInventory(result, block, material, pos, type);
-                        if (result.getDispenserItems().getOrDefault(pos, 0) > 0) {
+                        if (!result.getInventoryItemCounts().getOrDefault(pos, Collections.emptyMap()).isEmpty()) {
                             result.getBlockCounts().merge(material, 1, Integer::sum);
                         }
                     } else {
@@ -93,19 +93,6 @@ public class AutoChecker {
         return result;
     }
 
-    private static final Map<Material, Set<Material>> itemsInInv = new EnumMap<>(Material.class);
-
-    static {
-        itemsInInv.put(Material.BUCKET, EnumSet.of(Material.DISPENSER));
-        itemsInInv.put(Material.TNT, EnumSet.of(Material.CHEST, Material.BARREL, Material.SHULKER_BOX, Material.BLACK_SHULKER_BOX, Material.BLUE_SHULKER_BOX,
-                Material.BROWN_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.GRAY_SHULKER_BOX, Material.GREEN_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX,
-                Material.LIGHT_GRAY_SHULKER_BOX, Material.LIME_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.ORANGE_SHULKER_BOX,
-                Material.PINK_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.WHITE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX));
-        itemsInInv.put(Material.FIRE_CHARGE, EnumSet.of(Material.DISPENSER));
-        itemsInInv.put(Material.ARROW, EnumSet.of(Material.DISPENSER));
-        AutoCheckerItems.impl.getAllowedMaterialsInInventory().forEach(material -> itemsInInv.put(material, AutoCheckerItems.impl.getInventoryMaterials()));
-    }
-
     private void checkInventory(AutoChecker.BlockScanResult result, BaseBlock block, Material material, BlockPos pos, GameModeConfig<Material, String> type) {
         CompoundTag nbt = block.getNbtData();
         if (nbt == null) {
@@ -122,7 +109,7 @@ public class AutoChecker {
         List<CompoundTag> items = nbt.getList("Items", CompoundTag.class);
         if (items.isEmpty()) return; // Leeres Inventar
 
-        int counter = 0;
+        Map<Material, Integer> itemCounts = new EnumMap<>(Material.class);
         int windChargeCount = 0;
         for (CompoundTag item : items) {
             if (!item.containsKey("id")) {
@@ -136,16 +123,19 @@ public class AutoChecker {
 
             if (type.Schematic.Type.getName().equals("wargearseason26") && material == Material.DISPENSER && itemType == Material.WIND_CHARGE) {
                 windChargeCount += item.getInt("count");
-            } else if (!itemsInInv.getOrDefault(itemType, EnumSet.noneOf(Material.class)).contains(material)) {
+            } else if (type.Schematic.getItemAmount(material, itemType) == 0) {
                 result.getForbiddenItems().computeIfAbsent(pos, blockVector3 -> new HashSet<>()).add(itemType);
-            } else if (material == Material.DISPENSER && (itemType == Material.ARROW || itemType == Material.FIRE_CHARGE)) {
-                counter += item.getInt("count");
+            } else {
+                itemCounts.merge(itemType, item.getInt("count"), Integer::sum);
             }
             if (item.containsKey("tag")) {
                 result.getForbiddenNbt().computeIfAbsent(pos, blockVector3 -> new HashSet<>()).add(itemType);
             }
         }
-        result.getDispenserItems().put(pos, counter);
+        if (!itemCounts.isEmpty()) {
+            result.getInventoryItemCounts().put(pos, itemCounts);
+            result.getInventoryBlockType().put(pos, material);
+        }
         result.getWindChargeCount().put(pos, windChargeCount);
     }
 
@@ -156,7 +146,8 @@ public class AutoChecker {
         private final List<BlockPos> defunctNbt = new ArrayList<>();
         private final List<BlockPos> records = new ArrayList<>();
         private final Map<Material, List<BlockPos>> designBlocks = new EnumMap<>(Material.class);
-        private final Map<BlockPos, Integer> dispenserItems = new HashMap<>();
+        private final Map<BlockPos, Map<Material, Integer>> inventoryItemCounts = new HashMap<>();
+        private final Map<BlockPos, Material> inventoryBlockType = new HashMap<>();
         private final Map<BlockPos, Integer> windChargeCount = new HashMap<>();
         private final Map<BlockPos, Set<Material>> forbiddenItems = new HashMap<>();
         private final Map<BlockPos, Set<Material>> forbiddenNbt = new HashMap<>();

SchematicSystem/src/de/steamwar/schematicsystem/autocheck/AutoCheckerItems.java

@@ -1,51 +0,0 @@
-/*
- *   This file is a part of the SteamWar software.
- *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
- *
- *   This program is free software: you can redistribute it and/or modify
- *   it under the terms of the GNU Affero General Public License as published by
- *   the Free Software Foundation, either version 3 of the License, or
- *   (at your option) any later version.
- *
- *   This program is distributed in the hope that it will be useful,
- *   but WITHOUT ANY WARRANTY; without even the implied warranty of
- *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- *   GNU Affero General Public License for more details.
- *
- *   You should have received a copy of the GNU Affero General Public License
- *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package de.steamwar.schematicsystem.autocheck;
-
-import org.bukkit.Material;
-
-import java.util.EnumSet;
-import java.util.Set;
-
-public class AutoCheckerItems {
-
-    public static final AutoCheckerItems impl = new AutoCheckerItems();
-
-    private static final Set<Material> INVENTORY = EnumSet.of(Material.BARREL, Material.BLAST_FURNACE, Material.BREWING_STAND, Material.CAMPFIRE,
-            Material.CHEST, Material.DISPENSER, Material.DROPPER, Material.FURNACE, Material.HOPPER, Material.JUKEBOX, Material.SHULKER_BOX,
-            Material.WHITE_SHULKER_BOX, Material.ORANGE_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX, Material.YELLOW_SHULKER_BOX,
-            Material.LIME_SHULKER_BOX, Material.PINK_SHULKER_BOX, Material.GRAY_SHULKER_BOX, Material.LIGHT_GRAY_SHULKER_BOX, Material.CYAN_SHULKER_BOX,
-            Material.PURPLE_SHULKER_BOX, Material.BLUE_SHULKER_BOX, Material.BROWN_SHULKER_BOX, Material.GREEN_SHULKER_BOX, Material.RED_SHULKER_BOX,
-            Material.BLACK_SHULKER_BOX, Material.SMOKER, Material.TRAPPED_CHEST);
-
-    private static final Set<Material> FLOWERS = EnumSet.of(Material.CORNFLOWER, Material.POPPY, Material.FERN, Material.DANDELION, Material.BLUE_ORCHID,
-            Material.ALLIUM, Material.AZURE_BLUET, Material.RED_TULIP, Material.ORANGE_TULIP, Material.WHITE_TULIP, Material.PINK_TULIP, Material.OXEYE_DAISY,
-            Material.LILY_OF_THE_VALLEY, Material.WITHER_ROSE, Material.SUNFLOWER, Material.DIAMOND_HORSE_ARMOR, Material.IRON_HORSE_ARMOR,
-            Material.GOLDEN_HORSE_ARMOR, Material.LEATHER_HORSE_ARMOR, Material.HONEY_BOTTLE, Material.LILAC, Material.ROSE_BUSH, Material.PEONY,
-            Material.TALL_GRASS, Material.LARGE_FERN);
-
-    public Set<Material> getInventoryMaterials() {
-        return INVENTORY;
-    }
-
-    public Set<Material> getAllowedMaterialsInInventory() {
-        return FLOWERS;
-    }
-}

SchematicSystem/src/de/steamwar/schematicsystem/autocheck/AutoCheckerResult.java

@@ -50,7 +50,7 @@ public class AutoCheckerResult {
                 isSizeOk() &&
                 isBlockCountOk() &&
                 isLimitedBlocksOK() &&
-                isDispenserItemsOK() &&
+                isInventoryItemsOK() &&
                 isWindchargeCountOK() &&
                 !type.isAfterDeadline() &&
                 entities.isEmpty() &&
@@ -71,8 +71,14 @@ public class AutoCheckerResult {
         }
     }
 
-    public boolean isDispenserItemsOK() {
-        return blockScanResult.getDispenserItems().values().stream().allMatch(i -> i <= type.Schematic.MaxDispenserItems);
+    public boolean isInventoryItemsOK() {
+        return blockScanResult.getInventoryItemCounts().entrySet().stream().allMatch(posEntry -> {
+            Material inventory = blockScanResult.getInventoryBlockType().get(posEntry.getKey());
+            return posEntry.getValue().entrySet().stream().allMatch(itemEntry -> {
+                int cap = type.Schematic.getItemAmount(inventory, itemEntry.getKey());
+                return itemEntry.getValue() <= cap;
+            });
+        });
     }
 
     public boolean hasWarnings() {
@@ -100,13 +106,8 @@ public class AutoCheckerResult {
     }
 
     public boolean isLimitedBlocksOK() {
-        try {
-            return type.Schematic.Limited.entrySet().stream()
-                    .map(setIntegerEntry -> setIntegerEntry.getKey().stream().map(blockScanResult.getBlockCounts()::get).map(i -> i == null || i <= setIntegerEntry.getValue()).reduce(Boolean::logicalAnd).orElse(false))
-                    .reduce(Boolean::logicalAnd).orElse(true);
-        } catch (NullPointerException e) {
-            return false;
-        }
+        return blockScanResult.getBlockCounts().entrySet().stream()
+                .allMatch(entry -> entry.getValue() <= type.Schematic.getMaxCount(entry.getKey()));
     }
 
     public boolean isDesignBlastResistanceOK() {
@@ -130,14 +131,13 @@ public class AutoCheckerResult {
             SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_BLOCKS", p, blockScanResult.getBlockCounts().values().stream().reduce(Integer::sum).orElse(0), type.Schematic.MaxBlocks);
         }
         if (!isLimitedBlocksOK()) {
-            type.Schematic.Limited.forEach((materials, integer) -> {
-                for (Material mat : materials) {
-                    if (mat != null && blockScanResult.getBlockCounts().getOrDefault(mat, 0) > integer) {
-                        if (integer == 0) {
-                            SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_FORBIDDEN_BLOCK", p, mat.name());
-                        } else {
-                            SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_TOO_MANY_BLOCK", p, mat.name(), blockScanResult.getBlockCounts().getOrDefault(mat, 0), integer);
-                        }
+            blockScanResult.getBlockCounts().forEach((mat, count) -> {
+                int maxCount = type.Schematic.getMaxCount(mat);
+                if (count > maxCount) {
+                    if (maxCount == 0) {
+                        SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_FORBIDDEN_BLOCK", p, mat.name());
+                    } else {
+                        SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_TOO_MANY_BLOCK", p, mat.name(), count, maxCount);
                     }
                 }
             });
@@ -155,13 +155,20 @@ public class AutoCheckerResult {
             });
         }
 
-        blockScanResult.getDispenserItems().entrySet().stream().filter(blockVector3IntegerEntry -> blockVector3IntegerEntry.getValue() > type.Schematic.MaxDispenserItems).forEach(blockVector3IntegerEntry -> {
-            SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_TOO_MANY_DISPENSER_ITEMS", p, SchematicSystem.MESSAGE.parse("AUTO_CHECKER_RESULT_TELEPORT_HERE", p), tpCommandTo(blockVector3IntegerEntry.getKey()),
-                    blockVector3IntegerEntry.getKey().getBlockX(),
-                    blockVector3IntegerEntry.getKey().getBlockY(),
-                    blockVector3IntegerEntry.getKey().getBlockZ(),
-                    blockVector3IntegerEntry.getValue(),
-                    type.Schematic.MaxDispenserItems);
+        blockScanResult.getInventoryItemCounts().forEach((pos, itemCounts) -> {
+            Material inventory = blockScanResult.getInventoryBlockType().get(pos);
+            itemCounts.forEach((itemType, count) -> {
+                int cap = type.Schematic.getItemAmount(inventory, itemType);
+                if (count <= cap) return;
+                SchematicSystem.MESSAGE.sendPrefixless("AUTO_CHECKER_RESULT_TOO_MANY_INVENTORY_ITEMS", p, SchematicSystem.MESSAGE.parse("AUTO_CHECKER_RESULT_TELEPORT_HERE", p), tpCommandTo(pos),
+                        pos.getBlockX(),
+                        pos.getBlockY(),
+                        pos.getBlockZ(),
+                        count,
+                        cap,
+                        itemType.name(),
+                        inventory.name());
+            });
         });
 
         blockScanResult.getRecords().forEach(blockVector3 -> {

SchematicSystem/src/de/steamwar/schematicsystem/commands/schematiccommand/SchematicCommand.java

@@ -197,27 +197,31 @@ public class SchematicCommand extends SWCommand {
             clipboard.setBlock(vector, block.toBaseBlock(builder.build()));
         }
 
-        if (type.Schematic.MaxDispenserItems > 0) {
-            for (Map.Entry<BlockPos, Integer> entry : result.getBlockScanResult().getDispenserItems().entrySet()) {
-                if (entry.getValue() <= type.Schematic.MaxDispenserItems) {
+        for (Map.Entry<BlockPos, Map<Material, Integer>> posEntry : result.getBlockScanResult().getInventoryItemCounts().entrySet()) {
+            BlockPos pos = posEntry.getKey();
+            Material inventory = result.getBlockScanResult().getInventoryBlockType().get(pos);
+
+            for (Map.Entry<Material, Integer> itemEntry : posEntry.getValue().entrySet()) {
+                Material itemType = itemEntry.getKey();
+                Integer cap = type.Schematic.getItemAmount(inventory, itemType);
+                if (itemEntry.getValue() <= cap) {
                     continue;
                 }
 
-                BlockPos pos = entry.getKey();
                 BlockVector3 vector = BlockVector3.at(pos.getX(), pos.getY(), pos.getZ());
                 BaseBlock block = clipboard.getFullBlock(vector);
                 CompoundTag tag = block.getNbtData();
                 CompoundTagBuilder builder = tag.createBuilder();
                 List<CompoundTag> items = new ArrayList<>(tag.getList("Items", CompoundTag.class));
-                Collections.reverse(items); // To let the first item be in the Dispenser
+                Collections.reverse(items); // To let the first item be in the inventory
                 List<CompoundTag> list = new ArrayList<>();
-                int diff = entry.getValue() - type.Schematic.MaxDispenserItems;
+                int diff = itemEntry.getValue() - cap;
                 for (CompoundTag item : items) {
                     if (item == null) {
                         continue;
                     }
 
-                    if (diff == 0) {
+                    if (diff == 0 || Material.matchMaterial(item.getString("id")) != itemType) {
                         list.add(item);
                         continue;
                     }
@@ -238,9 +242,9 @@ public class SchematicCommand extends SWCommand {
         }
 
         if (!result.isLimitedBlocksOK()) {
-            Set<Material> toReplace = type.Schematic.Limited.entrySet().stream()
-                    .filter(setIntegerEntry -> setIntegerEntry.getValue() == 0)
-                    .flatMap(setIntegerEntry -> setIntegerEntry.getKey().stream())
+            Set<Material> toReplace = type.Schematic.Limited.stream()
+                    .filter(rule -> rule.Amount == 0)
+                    .flatMap(rule -> rule.Materials.stream())
                     .collect(Collectors.toSet());
             BlockState replaceType = Objects.requireNonNull(toReplace.contains(Material.END_STONE) ? BlockTypes.IRON_BLOCK : BlockTypes.END_STONE).getDefaultState();
             BlockVector3 min = clipboard.getMinimumPoint();

SpigotCore/SpigotCore_Main/src/de/steamwar/sql/SQLWrapperImpl.java

@@ -28,7 +28,10 @@ import org.bukkit.entity.Player;
 
 import java.io.File;
 import java.util.Arrays;
+import java.util.Collections;
+import java.util.EnumSet;
 import java.util.List;
+import java.util.Set;
 import java.util.stream.Collectors;
 
 public class SQLWrapperImpl implements SQLWrapper<Material> {
@@ -52,6 +55,45 @@ public class SQLWrapperImpl implements SQLWrapper<Material> {
                 .collect(Collectors.toList());
     }
 
+    /**
+     * Storage-type inventory materials (chests, barrels, shulker boxes of any color).
+     */
+    private static final Set<Material> STORAGE_MATERIALS = Collections.unmodifiableSet(EnumSet.of(
+            Material.CHEST, Material.TRAPPED_CHEST, Material.BARREL, Material.SHULKER_BOX,
+            Material.WHITE_SHULKER_BOX, Material.ORANGE_SHULKER_BOX, Material.MAGENTA_SHULKER_BOX, Material.LIGHT_BLUE_SHULKER_BOX,
+            Material.YELLOW_SHULKER_BOX, Material.LIME_SHULKER_BOX, Material.PINK_SHULKER_BOX, Material.GRAY_SHULKER_BOX,
+            Material.LIGHT_GRAY_SHULKER_BOX, Material.CYAN_SHULKER_BOX, Material.PURPLE_SHULKER_BOX, Material.BLUE_SHULKER_BOX,
+            Material.BROWN_SHULKER_BOX, Material.GREEN_SHULKER_BOX, Material.RED_SHULKER_BOX, Material.BLACK_SHULKER_BOX
+    ));
+
+    /**
+     * Every inventory material - {@link #STORAGE_MATERIALS} plus the "functional" containers that
+     * are not storage (dispenser, dropper, hopper, the furnace family, brewing stand, campfire,
+     * jukebox). Built on top of {@link #STORAGE_MATERIALS} so anything added there is automatically
+     * included here.
+     */
+    private static final Set<Material> INVENTORY_MATERIALS;
+
+    static {
+        Set<Material> materials = EnumSet.copyOf(STORAGE_MATERIALS);
+        materials.addAll(EnumSet.of(
+                Material.DISPENSER, Material.DROPPER, Material.HOPPER,
+                Material.FURNACE, Material.BLAST_FURNACE, Material.SMOKER,
+                Material.BREWING_STAND, Material.CAMPFIRE, Material.JUKEBOX
+        ));
+        INVENTORY_MATERIALS = Collections.unmodifiableSet(materials);
+    }
+
+    @Override
+    public Set<Material> getStorageMaterials() {
+        return STORAGE_MATERIALS;
+    }
+
+    @Override
+    public Set<Material> getInventoryMaterials() {
+        return INVENTORY_MATERIALS;
+    }
+
     private static final String SERVER_VERSION = Bukkit.getServer().getVersion();
 
     @Override

VelocityCore/src/de/steamwar/velocitycore/listeners/ConnectionListener.java

@@ -27,6 +27,7 @@ import com.velocitypowered.api.event.player.KickedFromServerEvent;
 import com.velocitypowered.api.network.ProtocolVersion;
 import com.velocitypowered.api.permission.Tristate;
 import com.velocitypowered.api.proxy.Player;
+import com.velocitypowered.api.util.ServerLink;
 import de.steamwar.linkage.Linked;
 import de.steamwar.messages.Chatter;
 import de.steamwar.messages.Message;
@@ -45,9 +46,7 @@ import de.steamwar.velocitycore.mods.ModUtils;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.event.ClickEvent;
 
-import java.util.HashSet;
-import java.util.Set;
-import java.util.UUID;
+import java.util.*;
 import java.util.concurrent.TimeUnit;
 
 @Linked
@@ -79,9 +78,27 @@ public class ConnectionListener extends BasicListener {
         });
     }
 
+    private static final List<ServerLink> SERVER_LINKS = getServerLinks();
+
+    private static List<ServerLink> getServerLinks() {
+        List<ServerLink> serverLinks = new ArrayList<>();
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.BUG_REPORT, "https://git.steamwar.de/SteamWar/SteamWar/issues/new"));
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.COMMUNITY_GUIDELINES, "https://steamwar.de/verhaltensrichtlinien/"));
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.SUPPORT, "https://discord.com/channels/690530484920385586/870028487455571999"));
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.COMMUNITY, "https://steamwar.de/discord"));
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.WEBSITE, "https://steamwar.de/"));
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.NEWS, "https://discord.com/channels/690530484920385586/690535200865910794"));
+        serverLinks.add(ServerLink.serverLink(ServerLink.Type.ANNOUNCEMENTS, "https://discord.com/channels/690530484920385586/690535200865910794"));
+        return serverLinks;
+    }
+
     @Subscribe
     public void onPostLogin(PostLoginEvent event) {
         Player player = event.getPlayer();
+        if (player.getProtocolVersion().noLessThan(ProtocolVersion.MINECRAFT_1_21)) {
+            player.setServerLinks(SERVER_LINKS);
+        }
+
         SteamwarUser user = SteamwarUser.get(player.getUniqueId());
         Chatter chatter = Chatter.of(player);
         CheckCommand.sendReminder(chatter);

settings.gradle.kts

@@ -21,6 +21,12 @@ import org.apache.tools.ant.taskdefs.condition.Os
 import java.net.URI
 import java.util.*
 
+pluginManagement {
+    plugins {
+        kotlin("plugin.lombok") version "2.3.20"
+    }
+}
+
 rootProject.name = "SteamWar"
 
 private val isInCi by lazy { Os.isFamily(Os.FAMILY_UNIX) && ProcessBuilder("hostname").start().inputStream.bufferedReader().readText().startsWith("steamwar.de") }