Move listener to permanent

Add event handler
Add listener to prevent dried ghasts from growing
2026-06-17 21:21:17 +02:00 · 2026-06-17 21:10:55 +02:00 · 2026-06-17 21:09:07 +02:00 · 2026-06-12 15:14:09 +02:00 · 2026-06-12 15:07:46 +02:00 · 2026-06-12 14:52:46 +02:00
31 changed files with 3116 additions and 68 deletions
@@ -25,6 +25,7 @@ import de.steamwar.bausystem.configplayer.ConfigConverter;
 import de.steamwar.bausystem.features.gui.BauGUI;
 import de.steamwar.bausystem.features.script.lua.SteamWarLuaPlugin;
 import de.steamwar.bausystem.features.script.lua.libs.LuaLib;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
 import de.steamwar.bausystem.features.slaves.panzern.Panzern;
 import de.steamwar.bausystem.features.slaves.panzern.PanzernAlgorithm;
 import de.steamwar.bausystem.features.tracer.TraceManager;
@@ -111,6 +112,9 @@ public class BauSystem extends JavaPlugin implements Listener {
                if (any instanceof ConfigConverter) {
                    Config.addConfigConverter((ConfigConverter) any);
                }
+                if (any instanceof BoundingBoxLoader) {
+                    ((BoundingBoxLoader) any).load();
+                }
            }
        };
        try {
@@ -19,17 +19,28 @@

 package de.steamwar.bausystem.features.slaves.laufbau;

+import com.sk89q.worldedit.blocks.SkullBlock;
 import com.sk89q.worldedit.world.block.BaseBlock;
 import de.steamwar.inventory.SWItem;
 import lombok.Getter;
 import lombok.ToString;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.Bisected;
 import org.bukkit.block.data.BlockData;
+import org.bukkit.block.data.Directional;
+import org.bukkit.block.data.Waterlogged;
+import org.bukkit.block.data.type.*;

 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Random;
 import java.util.function.Consumer;

+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
@ToString
@Getter
 public class BlockBoundingBox {
@@ -81,4 +92,197 @@ public class BlockBoundingBox {
    public double volume() {
        return volume;
    }
+
+    static {
+        addPixel(Material.AIR.createBlockData(), 0, 0, 0, 0, 0, 0, null);
+        // addPixel(Material.COBWEB.createBlockData(), 0, 0, 0, 0, 0, 0, createItem("LAUFBAU_BLOCK_COBWEB", Material.COBWEB));
+        addPixel(Material.END_STONE.createBlockData(), 0, 0, 0, 16, 16, 16, null);
+
+        addPixel(Material.DIRT_PATH.createBlockData(), 0, 0, 0, 16, 15, 16, createItem("LAUFBAU_BLOCK_GRASS_PATH", Material.DIRT_PATH));
+        addPixel(Material.MUD.createBlockData(), 0, 0, 0, 16, 14, 16, createItem("LAUFBAU_BLOCK_SOUL_SAND", Material.SOUL_SAND));
+
+        Cocoa cocoaNorth = (Cocoa) Material.COCOA.createBlockData();
+        cocoaNorth.setAge(2);
+        cocoaNorth.setFacing(BlockFace.NORTH);
+        addPixel(cocoaNorth, 4, 3, 1, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_NORTH"));
+
+        Cocoa cocoaSouth = (Cocoa) Material.COCOA.createBlockData();
+        cocoaSouth.setAge(2);
+        cocoaSouth.setFacing(BlockFace.SOUTH);
+        addPixel(cocoaSouth, 4, 3, 7, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_SOUTH"));
+
+        Cocoa cocoaWest = (Cocoa) Material.COCOA.createBlockData();
+        cocoaWest.setAge(2);
+        cocoaWest.setFacing(BlockFace.WEST);
+        addPixel(cocoaWest, 1, 3, 4, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_WEST"));
+
+        Cocoa cocoaEast = (Cocoa) Material.COCOA.createBlockData();
+        cocoaEast.setAge(2);
+        cocoaEast.setFacing(BlockFace.EAST);
+        addPixel(cocoaEast, 7, 3, 4, 8, 9, 8, createItem("LAUFBAU_BLOCK_COCOA", Material.COCOA_BEANS, "LAUFBAU_FACING_EAST"));
+
+        TurtleEgg singleTurtleEgg = (TurtleEgg) Material.TURTLE_EGG.createBlockData();
+        singleTurtleEgg.setEggs(1);
+        singleTurtleEgg.setHatch(0);
+        addPixel(singleTurtleEgg, 4, 0, 3, 9, 7, 9, createItem("LAUFBAU_BLOCK_TURTLE_EGG", Material.TURTLE_EGG, "LAUFBAU_COUNT_1"));
+
+        TurtleEgg doubleTurtleEgg = (TurtleEgg) Material.TURTLE_EGG.createBlockData();
+        doubleTurtleEgg.setEggs(2);
+        doubleTurtleEgg.setHatch(0);
+        addPixel(doubleTurtleEgg, 1, 0, 1, 14, 7, 14, createItem("LAUFBAU_BLOCK_TURTLE_EGG", Material.TURTLE_EGG, "LAUFBAU_COUNT_2"));
+
+        addPixel(Material.CHEST.createBlockData(), 1, 0, 1, 14, 14, 14, createItem("LAUFBAU_BLOCK_CHEST", Material.CHEST));
+
+        Snow snowLayers8 = (Snow) Material.SNOW.createBlockData();
+        snowLayers8.setLayers(8);
+        addPixel(snowLayers8, 0, 0, 0, 16, 14, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_8"));
+
+        Directional headNorth = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
+        headNorth.setFacing(BlockFace.NORTH);
+        addPixel(headNorth, 4, 4, 8, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_NORTH"), BlockBoundingBox::randomPlayerHead);
+
+        Directional headSouth = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
+        headSouth.setFacing(BlockFace.SOUTH);
+        addPixel(headSouth, 4, 4, 0, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_SOUTH"), BlockBoundingBox::randomPlayerHead);
+
+        Directional headWest = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
+        headWest.setFacing(BlockFace.WEST);
+        addPixel(headWest, 8, 4, 4, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_WEST"), BlockBoundingBox::randomPlayerHead);
+
+        Directional headEast = (Directional) Material.PLAYER_WALL_HEAD.createBlockData();
+        headEast.setFacing(BlockFace.EAST);
+        addPixel(headEast, 0, 4, 4, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_WALL_HEAD", Material.PLAYER_HEAD, "LAUFBAU_FACING_EAST"), BlockBoundingBox::randomPlayerHead);
+
+        Snow snowLayers7 = (Snow) Material.SNOW.createBlockData();
+        snowLayers7.setLayers(7);
+        addPixel(snowLayers7, 0, 0, 0, 16, 12, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_7"));
+
+        Snow snowLayers6 = (Snow) Material.SNOW.createBlockData();
+        snowLayers6.setLayers(6);
+        addPixel(snowLayers6, 0, 0, 0, 16, 10, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_6"));
+
+        addPixel(Material.STONECUTTER.createBlockData(), 0, 0, 0, 16, 9, 16, createItem("LAUFBAU_BLOCK_STONECUTTER", Material.STONECUTTER));
+
+        addPixel(Material.PLAYER_HEAD.createBlockData(), 4, 0, 4, 8, 8, 8, createItem("LAUFBAU_BLOCK_PLAYER_HEAD", Material.PLAYER_HEAD), BlockBoundingBox::randomPlayerHead);
+
+        addPixel(Material.CAKE.createBlockData(), 1, 0, 1, 14, 8, 14, createItem("LAUFBAU_BLOCK_CAKE", Material.CAKE));
+
+        Slab bottomSlab = (Slab) Material.END_STONE_BRICK_SLAB.createBlockData();
+        bottomSlab.setType(Slab.Type.BOTTOM);
+        addPixel(bottomSlab, 0, 0, 0, 16, 8, 16, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_SLAB", Material.END_STONE_BRICK_SLAB, "LAUFBAU_TYPE_BOTTOM"));
+
+        Slab topSlab = (Slab) Material.END_STONE_BRICK_SLAB.createBlockData();
+        topSlab.setType(Slab.Type.TOP);
+        addPixel(topSlab, 0, 8, 0, 16, 8, 16, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_SLAB", Material.END_STONE_BRICK_SLAB, "LAUFBAU_TYPE_TOP"));
+
+        SeaPickle quadSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
+        quadSeaPickle.setWaterlogged(false);
+        quadSeaPickle.setPickles(4);
+        addPixel(quadSeaPickle, 2, 0, 2, 12, 7, 12, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_4"));
+
+        Campfire campfire = (Campfire) Material.CAMPFIRE.createBlockData();
+        campfire.setSignalFire(false);
+        campfire.setLit(false);
+        addPixel(campfire, 0, 0, 0, 16, 7, 16, createItem("LAUFBAU_BLOCK_CAMPFIRE", Material.CAMPFIRE));
+
+        SeaPickle trippleSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
+        trippleSeaPickle.setWaterlogged(false);
+        trippleSeaPickle.setPickles(3);
+        addPixel(trippleSeaPickle, 2, 0, 2, 12, 6, 12, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_3"));
+
+        SeaPickle doubleSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
+        doubleSeaPickle.setWaterlogged(false);
+        doubleSeaPickle.setPickles(2);
+        addPixel(doubleSeaPickle, 3, 0, 3, 10, 6, 10, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_2"));
+
+        SeaPickle singleSeaPickle = (SeaPickle) Material.SEA_PICKLE.createBlockData();
+        singleSeaPickle.setWaterlogged(false);
+        singleSeaPickle.setPickles(1);
+        addPixel(singleSeaPickle, 6, 0, 6, 4, 6, 4, createItem("LAUFBAU_BLOCK_SEA_PICKLE", Material.SEA_PICKLE, "LAUFBAU_COUNT_1"));
+
+        addPixel(Material.FLOWER_POT.createBlockData(), 5, 0, 5, 6, 6, 6, createItem("LAUFBAU_BLOCK_FLOWER_POT", Material.FLOWER_POT));
+
+        Snow snowLayers3 = (Snow) Material.SNOW.createBlockData();
+        snowLayers3.setLayers(3);
+        addPixel(snowLayers3, 0, 0, 0, 16, 4, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_3"));
+
+        TrapDoor bottomTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
+        bottomTrapDoor.setHalf(Bisected.Half.BOTTOM);
+        addPixel(bottomTrapDoor, 0, 0, 0, 16, 3, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_HALF_BOTTOM"));
+
+        TrapDoor topTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
+        topTrapDoor.setHalf(Bisected.Half.TOP);
+        addPixel(topTrapDoor, 0, 13, 0, 16, 3, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_HALF_TOP"));
+
+        Snow snowLayers2 = (Snow) Material.SNOW.createBlockData();
+        snowLayers2.setLayers(2);
+        addPixel(snowLayers2, 0, 0, 0, 16, 2, 16, createItem("LAUFBAU_BLOCK_SNOW", Material.SNOW, "LAUFBAU_LAYERS_2"));
+
+        addPixel(Material.LILY_PAD.createBlockData(), 1, 0, 1, 14, 1.5, 14, createItem("LAUFBAU_BLOCK_LILY_PAD", Material.LILY_PAD));
+        addPixel(Material.WHITE_CARPET.createBlockData(), 0, 0, 0, 16, 1, 16, createItem("LAUFBAU_BLOCK_WHITE_CARPET", Material.WHITE_CARPET));
+
+        Directional endRodBottomTop = (Directional) Material.END_ROD.createBlockData();
+        endRodBottomTop.setFacing(BlockFace.UP);
+        addPixel(endRodBottomTop, 6, 0, 6, 4, 16, 4, createItem("LAUFBAU_BLOCK_END_ROD", Material.END_ROD, "LAUFBAU_FACING_UP", "LAUFBAU_FACING_DOWN"));
+
+        Directional endRodNorthSouth = (Directional) Material.END_ROD.createBlockData();
+        endRodNorthSouth.setFacing(BlockFace.NORTH);
+        addPixel(endRodNorthSouth, 6, 6, 0, 4, 4, 16, createItem("LAUFBAU_BLOCK_END_ROD", Material.END_ROD, "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
+
+        Directional endRodEastWest = (Directional) Material.END_ROD.createBlockData();
+        endRodEastWest.setFacing(BlockFace.EAST);
+        addPixel(endRodEastWest, 0, 6, 6, 16, 4, 4, createItem("LAUFBAU_BLOCK_END_ROD", Material.END_ROD, "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
+
+        Directional lightningRodBottomTop = (Directional) Material.LIGHTNING_ROD.createBlockData();
+        lightningRodBottomTop.setFacing(BlockFace.UP);
+        addPixel(lightningRodBottomTop, 6, 0, 6, 4, 16, 4, createItem("LAUFBAU_BLOCK_LIGHTNING_ROD", Material.LIGHTNING_ROD, "LAUFBAU_FACING_UP", "LAUFBAU_FACING_DOWN"));
+
+        Directional lightningRodNorthSouth = (Directional) Material.LIGHTNING_ROD.createBlockData();
+        lightningRodNorthSouth.setFacing(BlockFace.NORTH);
+        addPixel(lightningRodNorthSouth, 6, 6, 0, 4, 4, 16, createItem("LAUFBAU_BLOCK_LIGHTNING_ROD", Material.LIGHTNING_ROD, "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
+
+        Directional lightningRodEastWest = (Directional) Material.LIGHTNING_ROD.createBlockData();
+        lightningRodEastWest.setFacing(BlockFace.EAST);
+        addPixel(lightningRodEastWest, 0, 6, 6, 16, 4, 4, createItem("LAUFBAU_BLOCK_LIGHTNING_ROD", Material.LIGHTNING_ROD, "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
+
+        Waterlogged conduit = (Waterlogged) Material.CONDUIT.createBlockData();
+        conduit.setWaterlogged(false);
+        addPixel(conduit, 5, 5, 5, 6, 6, 6, createItem("LAUFBAU_BLOCK_CONDUIT", Material.CONDUIT));
+
+        TrapDoor northTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
+        northTrapDoor.setFacing(BlockFace.NORTH);
+        northTrapDoor.setOpen(true);
+        addPixel(northTrapDoor, 0, 0, 13, 16, 16, 3, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_NORTH", "LAUFBAU_OPEN"));
+
+        TrapDoor southTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
+        southTrapDoor.setFacing(BlockFace.SOUTH);
+        southTrapDoor.setOpen(true);
+        addPixel(southTrapDoor, 0, 0, 0, 16, 16, 3, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_SOUTH", "LAUFBAU_OPEN"));
+
+        TrapDoor westTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
+        westTrapDoor.setFacing(BlockFace.WEST);
+        westTrapDoor.setOpen(true);
+        addPixel(westTrapDoor, 13, 0, 0, 3, 16, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_WEST", "LAUFBAU_OPEN"));
+
+        TrapDoor eastTrapDoor = (TrapDoor) Material.IRON_TRAPDOOR.createBlockData();
+        eastTrapDoor.setFacing(BlockFace.EAST);
+        eastTrapDoor.setOpen(true);
+        addPixel(eastTrapDoor, 0, 0, 0, 3, 16, 16, createItem("LAUFBAU_BLOCK_IRON_TRAPDOOR", Material.IRON_TRAPDOOR, "LAUFBAU_FACING_EAST", "LAUFBAU_OPEN"));
+    }
+
+    private static void addPixel(BlockData blockData, double xPixel, double yPixel, double zPixel, double dxPixel, double dyPixel, double dzPixel, SWItem swItem) {
+        new BlockBoundingBox(blockData, Arrays.asList(pixelCuboid(xPixel, yPixel, zPixel, dxPixel, dyPixel, dzPixel)), swItem);
+    }
+
+    private static void addPixel(BlockData blockData, double xPixel, double yPixel, double zPixel, double dxPixel, double dyPixel, double dzPixel, SWItem swItem, Consumer<BaseBlock> blockConsumer) {
+        new BlockBoundingBox(blockData, Arrays.asList(pixelCuboid(xPixel, yPixel, zPixel, dxPixel, dyPixel, dzPixel)), swItem, blockConsumer);
+    }
+
+    @SuppressWarnings("deprecation")
+    private static void randomPlayerHead(BaseBlock block) {
+        if (block instanceof SkullBlock) {
+            SkullBlock skullBlock = (SkullBlock) block;
+            skullBlock.setOwner(randomPlayerHead.get(random.nextInt(randomPlayerHead.size())).toString());
+        }
+    }
 }
@@ -0,0 +1,25 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau;
+
+public interface BoundingBoxLoader {
+
+    void load();
+}
@@ -22,7 +22,6 @@ package de.steamwar.bausystem.features.slaves.laufbau;
 import de.steamwar.bausystem.region.Point;
 import lombok.AllArgsConstructor;
 import lombok.Data;
-import org.bukkit.util.BoundingBox;

@Data
@AllArgsConstructor
@@ -34,15 +33,6 @@ public class Cuboid {
    private double dy;
    private double dz;

-    public Cuboid(BoundingBox boundingBox) {
-        this.x = boundingBox.getMinX();
-        this.y = boundingBox.getMinY();
-        this.z = boundingBox.getMinZ();
-        this.dx = boundingBox.getWidthX();
-        this.dy = boundingBox.getHeight();
-        this.dz = boundingBox.getWidthZ();
-    }
-
    public boolean intersects(Cuboid cuboid) {
        double minx = x - cuboid.dx;
        double miny = y - cuboid.dy;
@@ -24,52 +24,15 @@ import de.steamwar.bausystem.SWUtils;
 import de.steamwar.bausystem.shared.Pair;
 import de.steamwar.bausystem.utils.WorldEditUtils;
 import de.steamwar.command.SWCommand;
-import de.steamwar.inventory.SWItem;
 import de.steamwar.linkage.Linked;
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.EmptyBlockGetter;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.phys.shapes.CollisionContext;
 import org.bukkit.Bukkit;
 import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Registry;
-import org.bukkit.craftbukkit.block.CraftBlockType;
-import org.bukkit.craftbukkit.block.data.CraftBlockData;
-import org.bukkit.craftbukkit.util.CraftVoxelShape;
 import org.bukkit.entity.Player;
 import org.bukkit.scheduler.BukkitRunnable;
-import org.bukkit.util.VoxelShape;
-
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.stream.Collectors;

@Linked
 public class LaufbauCommand extends SWCommand {

-    static {
-        AtomicLong counter = new AtomicLong();
-        AtomicReference<VoxelShape> shape = new AtomicReference<>();
-        long time = System.currentTimeMillis();
-        Registry.BLOCK.forEach(blockType -> {
-            Block block = CraftBlockType.bukkitToMinecraftNew(blockType);
-            block.getStateDefinition().getPossibleStates().forEach(blockState -> {
-                VoxelShape voxelShape = new CraftVoxelShape(blockState.getCollisionShape(EmptyBlockGetter.INSTANCE, BlockPos.ZERO, CollisionContext.empty()));
-                shape.set(voxelShape);
-                Material material = blockType.asMaterial();
-                if (!material.isItem()) return;
-                new BlockBoundingBox(
-                        CraftBlockData.createData(blockState),
-                        voxelShape.getBoundingBoxes().stream().map(Cuboid::new).collect(Collectors.toList()),
-                        new SWItem(material, "Item")
-                );
-                counter.incrementAndGet();
-            });
-        });
-        System.out.println(System.currentTimeMillis() - time + "ms " + shape.get() + " " + counter.get());
-    }
-
    public LaufbauCommand() {
        super("laufbau", "laufsklave");
    }
@@ -0,0 +1,261 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.AmethystCluster;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class AmethystBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        floorSmallAmethystBud();
+        ceilingSmallAmethystBud();
+        northSmallAmethystBud();
+        southSmallAmethystBud();
+        eastSmallAmethystBud();
+        westSmallAmethystBud();
+
+        floorMediumAmethystBud();
+        ceilingMediumAmethystBud();
+        northMediumAmethystBud();
+        southMediumAmethystBud();
+        eastMediumAmethystBud();
+        westMediumAmethystBud();
+
+        floorLargeAmethystBud();
+        ceilingLargeAmethystBud();
+        northLargeAmethystBud();
+        southLargeAmethystBud();
+        eastLargeAmethystBud();
+        westLargeAmethystBud();
+
+        floorAmethystCluster();
+        ceilingAmethystCluster();
+        northAmethystCluster();
+        southAmethystCluster();
+        eastAmethystCluster();
+        westAmethystCluster();
+    }
+
+    private void floorSmallAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.UP);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 0, 4, 8, 3, 8));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_UP"));
+    }
+
+    private void ceilingSmallAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.DOWN);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 13, 4, 8, 3, 8));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_DOWN"));
+    }
+
+    private void northSmallAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 13, 8, 8, 3));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_NORTH"));
+    }
+
+    private void southSmallAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 0, 8, 8, 3));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_SOUTH"));
+    }
+
+    private void eastSmallAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 4, 4, 3, 8, 8));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_EAST"));
+    }
+
+    private void westSmallAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.SMALL_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(13, 4, 4, 3, 8, 8));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_SMALL_AMETHYST_BUD", Material.SMALL_AMETHYST_BUD, "LAUFBAU_FACING_WEST"));
+    }
+
+    private void floorMediumAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.UP);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 0, 3, 10, 4, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_UP"));
+    }
+
+    private void ceilingMediumAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.DOWN);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 12, 3, 10, 4, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_DOWN"));
+    }
+
+    private void northMediumAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 3, 12, 10, 10, 4));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_NORTH"));
+    }
+
+    private void southMediumAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 4));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_SOUTH"));
+    }
+
+    private void eastMediumAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 3, 3, 4, 10, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_EAST"));
+    }
+
+    private void westMediumAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.MEDIUM_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(12, 3, 3, 4, 10, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_MEDIUM_AMETHYST_BUD", Material.MEDIUM_AMETHYST_BUD, "LAUFBAU_FACING_WEST"));
+    }
+
+    private void floorLargeAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.UP);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 0, 3, 10, 5, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_UP"));
+    }
+
+    private void ceilingLargeAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.DOWN);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 11, 3, 10, 5, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_DOWN"));
+    }
+
+    private void northLargeAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 3, 11, 10, 10, 5));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_NORTH"));
+    }
+
+    private void southLargeAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 5));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_SOUTH"));
+    }
+
+    private void eastLargeAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 3, 3, 5, 10, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_EAST"));
+    }
+
+    private void westLargeAmethystBud() {
+        AmethystCluster cluster = (AmethystCluster) Material.LARGE_AMETHYST_BUD.createBlockData();
+        cluster.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(11, 3, 3, 5, 10, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_LARGE_AMETHYST_BUD", Material.LARGE_AMETHYST_BUD, "LAUFBAU_FACING_WEST"));
+    }
+
+    private void floorAmethystCluster() {
+        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
+        cluster.setFacing(BlockFace.UP);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 0, 3, 10, 7, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_UP"));
+    }
+
+    private void ceilingAmethystCluster() {
+        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
+        cluster.setFacing(BlockFace.DOWN);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 9, 3, 10, 7, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_DOWN"));
+    }
+
+    private void northAmethystCluster() {
+        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
+        cluster.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 3, 9, 10, 10, 7));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_NORTH"));
+    }
+
+    private void southAmethystCluster() {
+        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
+        cluster.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 7));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_SOUTH"));
+    }
+
+    private void eastAmethystCluster() {
+        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
+        cluster.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 3, 3, 7, 10, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_EAST"));
+    }
+
+    private void westAmethystCluster() {
+        AmethystCluster cluster = (AmethystCluster) Material.AMETHYST_CLUSTER.createBlockData();
+        cluster.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(9, 3, 3, 7, 10, 10));
+        new BlockBoundingBox(cluster, cuboidList, createItem("LAUFBAU_BLOCK_AMETHYST_CLUSTER", Material.AMETHYST_CLUSTER, "LAUFBAU_FACING_WEST"));
+    }
+}
@@ -0,0 +1,46 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class AzaleaBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        BlockData blockData = Material.FLOWERING_AZALEA.createBlockData();
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(6, 0, 6, 4, 8, 4));
+        new BlockBoundingBox(blockData, cuboidList, createItem("LAUFBAU_BLOCK_AZALEA", Material.FLOWERING_AZALEA));
+    }
+}
@@ -0,0 +1,149 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Bell;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class BellBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        ceilingBell();
+
+        floorNorthBell();
+        floorEastBell();
+
+        doubleWallNorthBell();
+        doubleWallEastBell();
+
+        singleWallNorthBell();
+        singleWallSouthBell();
+        singleWallEastBell();
+        singleWallWestBell();
+    }
+
+    public void ceilingBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.CEILING);
+        bell.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(7, 13, 7, 2, 3, 2));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_CEILING"));
+    }
+
+    public void floorNorthBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.FLOOR);
+        bell.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 4, 16, 16, 8));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void floorEastBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.FLOOR);
+        bell.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 0, 0, 8, 16, 16));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void doubleWallNorthBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.DOUBLE_WALL);
+        bell.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(7, 13, 0, 2, 2, 16));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_DOUBLE_WALL", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void doubleWallEastBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.DOUBLE_WALL);
+        bell.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(0, 13, 7, 16, 2, 2));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_DOUBLE_WALL", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void singleWallNorthBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
+        bell.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(7, 13, 0, 2, 2, 13));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void singleWallSouthBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
+        bell.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(7, 13, 3, 2, 2, 13));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void singleWallEastBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
+        bell.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(3, 13, 7, 13, 2, 2));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void singleWallWestBell() {
+        Bell bell = (Bell) Material.BELL.createBlockData();
+        bell.setAttachment(Bell.Attachment.SINGLE_WALL);
+        bell.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 2, 8));
+        cuboidList.add(pixelCuboid(5, 6, 5, 6, 8, 6));
+        cuboidList.add(pixelCuboid(0, 13, 7, 13, 2, 2));
+        new BlockBoundingBox(bell, cuboidList, createItem("LAUFBAU_BLOCK_BELL", Material.BELL, "LAUFBAU_ATTACHMENT_SINGLE_WALL", "LAUFBAU_FACING_WEST"));
+    }
+}
@@ -0,0 +1,46 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.type.BrewingStand;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class BrewingStandBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        BrewingStand brewingStand = (BrewingStand) Material.BREWING_STAND.createBlockData();
+        List<Cuboid> cuboids = new ArrayList<>();
+        cuboids.add(pixelCuboid(1, 0, 1, 14, 2, 14));
+        cuboids.add(pixelCuboid(7, 2, 7, 2, 12, 2));
+        new BlockBoundingBox(brewingStand, cuboids, createItem("LAUFBAU_BLOCK_BREWING_STAND", Material.BREWING_STAND));
+    }
+}
@@ -0,0 +1,62 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.Lightable;
+import org.bukkit.block.data.type.Candle;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class CandleBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        caked();
+
+        single();
+    }
+
+    private void caked() {
+        Lightable candleCake = (Lightable) Material.CYAN_CANDLE_CAKE.createBlockData();
+        candleCake.setLit(true);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(7, 8, 7, 2, 6, 2));
+        new BlockBoundingBox(candleCake, cuboidList, createItem("LAUFBAU_BLOCK_CANDLE_CAKE", Material.CAKE));
+    }
+
+    private void single() {
+        Candle candle = (Candle) Material.CYAN_CANDLE.createBlockData();
+        candle.setCandles(1);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(7, 0, 7, 2, 6, 2));
+        new BlockBoundingBox(candle, cuboidList, createItem("LAUFBAU_BLOCK_CANDLE", Material.CYAN_CANDLE, "LAUFBAU_COUNT_1"));
+    }
+}
@@ -0,0 +1,69 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Axis;
+import org.bukkit.Material;
+import org.bukkit.block.data.Orientable;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class ChainBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        bottomTopChain();
+        northSouthChain();
+        eastWestChain();
+    }
+
+    private void bottomTopChain() {
+        Orientable chainBottomTop = (Orientable) Material.CHAIN.createBlockData();
+        chainBottomTop.setAxis(Axis.Y);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(6.5, 0, 6.5, 3, 16, 3));
+        new BlockBoundingBox(chainBottomTop, cuboidList, createItem("LAUFBAU_BLOCK_CHAIN", Material.CHAIN, "LAUFBAU_FACING_UP", "LAUFBAU_FACING_DOWN"));
+    }
+
+    private void northSouthChain() {
+        Orientable chainBottomTop = (Orientable) Material.CHAIN.createBlockData();
+        chainBottomTop.setAxis(Axis.Z);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(6.5, 6.5, 0, 3, 3, 16));
+        new BlockBoundingBox(chainBottomTop, cuboidList, createItem("LAUFBAU_BLOCK_CHAIN", Material.CHAIN, "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    private void eastWestChain() {
+        Orientable chainBottomTop = (Orientable) Material.CHAIN.createBlockData();
+        chainBottomTop.setAxis(Axis.X);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 6.5, 6.5, 16, 3, 3));
+        new BlockBoundingBox(chainBottomTop, cuboidList, createItem("LAUFBAU_BLOCK_CHAIN", Material.CHAIN, "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
+    }
+}
@@ -0,0 +1,89 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.MultipleFacing;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class ChorusPlantBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        for (int nx = 0; nx < 2; nx++) {
+            for (int ny = 0; ny < 2; ny++) {
+                for (int nz = 0; nz < 2; nz++) {
+                    for (int px = 0; px < 2; px++) {
+                        for (int py = 0; py < 2; py++) {
+                            for (int pz = 0; pz < 2; pz++) {
+                                MultipleFacing chorusPlant = (MultipleFacing) Material.CHORUS_PLANT.createBlockData();
+                                List<String> lore = new ArrayList<>();
+                                List<Cuboid> cuboidList = new ArrayList<>();
+                                cuboidList.add(pixelCuboid(3, 3, 3, 10, 10, 10));
+                                if (nx == 1) {
+                                    lore.add("LAUFBAU_CONNECTION_WEST");
+                                    chorusPlant.setFace(BlockFace.WEST, true);
+                                    cuboidList.add(pixelCuboid(0, 3, 3, 3, 10, 10));
+                                }
+                                if (ny == 1) {
+                                    lore.add("LAUFBAU_CONNECTION_DOWN");
+                                    chorusPlant.setFace(BlockFace.DOWN, true);
+                                    cuboidList.add(pixelCuboid(3, 0, 3, 10, 3, 10));
+                                }
+                                if (nz == 1) {
+                                    lore.add("LAUFBAU_CONNECTION_NORTH");
+                                    chorusPlant.setFace(BlockFace.NORTH, true);
+                                    cuboidList.add(pixelCuboid(3, 3, 0, 10, 10, 3));
+                                }
+                                if (px == 1) {
+                                    lore.add("LAUFBAU_CONNECTION_EAST");
+                                    chorusPlant.setFace(BlockFace.EAST, true);
+                                    cuboidList.add(pixelCuboid(13, 3, 3, 3, 10, 10));
+                                }
+                                if (py == 1) {
+                                    lore.add("LAUFBAU_CONNECTION_UP");
+                                    chorusPlant.setFace(BlockFace.UP, true);
+                                    cuboidList.add(pixelCuboid(3, 13, 3, 10, 3, 10));
+                                }
+                                if (pz == 1) {
+                                    lore.add("LAUFBAU_CONNECTION_SOUTH");
+                                    chorusPlant.setFace(BlockFace.SOUTH, true);
+                                    cuboidList.add(pixelCuboid(3, 3, 13, 10, 10, 3));
+                                }
+                                new BlockBoundingBox(chorusPlant, cuboidList, createItem("LAUFBAU_BLOCK_CHORUS_PLANT", Material.CHORUS_PLANT, lore.toArray(new String[0])));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,45 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class DragonEggBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        BlockData blockData = Material.DRAGON_EGG.createBlockData();
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(1, 0, 1, 14, 16, 14));
+        new BlockBoundingBox(blockData, cuboidList, createItem("LAUFBAU_BLOCK_DRAGON_EGG", Material.DRAGON_EGG));
+    }
+}
@@ -0,0 +1,59 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.type.BigDripleaf;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class DripLeafBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        tiltNone();
+        tiltPartial();
+    }
+
+    private void tiltNone() {
+        BigDripleaf bigDripleaf = (BigDripleaf) Material.BIG_DRIPLEAF.createBlockData();
+        bigDripleaf.setTilt(BigDripleaf.Tilt.NONE);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 11, 0, 16, 4, 16));
+        new BlockBoundingBox(bigDripleaf, cuboidList, createItem("LAUFBAU_BLOCK_BIG_DRIP_LEAF", Material.BIG_DRIPLEAF, "LAUFBAU_TILT_NONE"));
+    }
+
+    private void tiltPartial() {
+        BigDripleaf bigDripleaf = (BigDripleaf) Material.BIG_DRIPLEAF.createBlockData();
+        bigDripleaf.setTilt(BigDripleaf.Tilt.PARTIAL);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 11, 0, 16, 2, 16));
+        new BlockBoundingBox(bigDripleaf, cuboidList, createItem("LAUFBAU_BLOCK_BIG_DRIP_LEAF", Material.BIG_DRIPLEAF, "LAUFBAU_TILT_PARTIAL"));
+    }
+}
@@ -0,0 +1,75 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Fence;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class FencesBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        for (int nx = 0; nx < 2; nx++) {
+            for (int nz = 0; nz < 2; nz++) {
+                for (int px = 0; px < 2; px++) {
+                    for (int pz = 0; pz < 2; pz++) {
+                        Fence fence = (Fence) Material.NETHER_BRICK_FENCE.createBlockData();
+                        List<String> lore = new ArrayList<>();
+                        List<Cuboid> cuboidList = new ArrayList<>();
+                        cuboidList.add(pixelCuboid(6, 0, 6, 4, 24, 4));
+                        if (nz == 1) {
+                            lore.add("LAUFBAU_CONNECTION_NORTH");
+                            fence.setFace(BlockFace.NORTH, true);
+                            cuboidList.add(pixelCuboid(6, 0, 0, 4, 24, 6));
+                        }
+                        if (pz == 1) {
+                            lore.add("LAUFBAU_CONNECTION_SOUTH");
+                            fence.setFace(BlockFace.SOUTH, true);
+                            cuboidList.add(pixelCuboid(6, 0, 10, 4, 24, 6));
+                        }
+                        if (nx == 1) {
+                            lore.add("LAUFBAU_CONNECTION_WEST");
+                            fence.setFace(BlockFace.WEST, true);
+                            cuboidList.add(pixelCuboid(0, 0, 6, 6, 24, 4));
+                        }
+                        if (px == 1) {
+                            lore.add("LAUFBAU_CONNECTION_EAST");
+                            fence.setFace(BlockFace.EAST, true);
+                            cuboidList.add(pixelCuboid(10, 0, 6, 6, 24, 4));
+                        }
+                        new BlockBoundingBox(fence, cuboidList, createItem("LAUFBAU_BLOCK_NETHER_BRICK_FENCE", Material.NETHER_BRICK_FENCE, lore.toArray(new String[0])));
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,157 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.FaceAttachable;
+import org.bukkit.block.data.type.Grindstone;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class GrindstoneBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        floorNorthGrindstone();
+        floorEastGrindstone();
+
+        ceilingNorthGrindstone();
+        ceilingEastGrindstone();
+
+        wallNorthGrindstone();
+        wallSouthGrindstone();
+        wallEastGrindstone();
+        wallWestGrindstone();
+    }
+
+    public void floorNorthGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.FLOOR);
+        grindstone.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 4, 2, 8, 12, 12));
+        cuboidList.add(pixelCuboid(2, 0, 6, 2, 7, 4));
+        cuboidList.add(pixelCuboid(12, 0, 6, 2, 7, 4));
+        cuboidList.add(pixelCuboid(2, 7, 5, 2, 6, 6));
+        cuboidList.add(pixelCuboid(12, 7, 5, 2, 6, 6));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void floorEastGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.FLOOR);
+        grindstone.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(2, 4, 4, 12, 12, 8));
+        cuboidList.add(pixelCuboid(6, 0, 2, 4, 7, 2));
+        cuboidList.add(pixelCuboid(6, 0, 12, 4, 7, 2));
+        cuboidList.add(pixelCuboid(5, 7, 2, 6, 6, 2));
+        cuboidList.add(pixelCuboid(5, 7, 12, 6, 6, 2));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_FLOOR", "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void ceilingNorthGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.CEILING);
+        grindstone.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 0, 2, 8, 12, 12));
+        cuboidList.add(pixelCuboid(2, 9, 6, 2, 7, 4));
+        cuboidList.add(pixelCuboid(12, 9, 6, 2, 7, 4));
+        cuboidList.add(pixelCuboid(2, 3, 5, 2, 6, 6));
+        cuboidList.add(pixelCuboid(12, 3, 5, 2, 6, 6));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_CEILING", "LAUFBAU_FACING_NORTH", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void ceilingEastGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.CEILING);
+        grindstone.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(2, 0, 4, 12, 12, 8));
+        cuboidList.add(pixelCuboid(6, 9, 2, 4, 7, 2));
+        cuboidList.add(pixelCuboid(6, 9, 12, 4, 7, 2));
+        cuboidList.add(pixelCuboid(5, 3, 2, 6, 6, 2));
+        cuboidList.add(pixelCuboid(5, 3, 12, 6, 6, 2));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_CEILING", "LAUFBAU_FACING_EAST", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void wallNorthGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
+        grindstone.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 2, 0, 8, 12, 12));
+        cuboidList.add(pixelCuboid(2, 6, 9, 2, 4, 7));
+        cuboidList.add(pixelCuboid(12, 6, 9, 2, 4, 7));
+        cuboidList.add(pixelCuboid(2, 5, 3, 2, 6, 6));
+        cuboidList.add(pixelCuboid(12, 5, 3, 2, 6, 6));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void wallSouthGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
+        grindstone.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 2, 4, 8, 12, 12));
+        cuboidList.add(pixelCuboid(2, 6, 0, 2, 4, 7));
+        cuboidList.add(pixelCuboid(12, 6, 0, 2, 4, 7));
+        cuboidList.add(pixelCuboid(2, 5, 7, 2, 6, 6));
+        cuboidList.add(pixelCuboid(12, 5, 7, 2, 6, 6));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void wallEastGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
+        grindstone.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(4, 2, 4, 12, 12, 8));
+        cuboidList.add(pixelCuboid(0, 6, 2, 7, 4, 2));
+        cuboidList.add(pixelCuboid(0, 6, 12, 7, 4, 2));
+        cuboidList.add(pixelCuboid(7, 5, 2, 6, 6, 2));
+        cuboidList.add(pixelCuboid(7, 5, 12, 6, 6, 2));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void wallWestGrindstone() {
+        Grindstone grindstone = (Grindstone) Material.GRINDSTONE.createBlockData();
+        grindstone.setAttachedFace(FaceAttachable.AttachedFace.WALL);
+        grindstone.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 2, 4, 12, 12, 8));
+        cuboidList.add(pixelCuboid(9, 6, 2, 7, 4, 2));
+        cuboidList.add(pixelCuboid(9, 6, 12, 7, 4, 2));
+        cuboidList.add(pixelCuboid(3, 5, 2, 6, 6, 2));
+        cuboidList.add(pixelCuboid(3, 5, 12, 6, 6, 2));
+        new BlockBoundingBox(grindstone, cuboidList, createItem("LAUFBAU_BLOCK_GRINDSTONE", Material.GRINDSTONE, "LAUFBAU_ATTACHMENT_WALL", "LAUFBAU_FACING_WEST"));
+    }
+}
@@ -0,0 +1,97 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Hopper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class HopperBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        downHopper();
+        northHopper();
+        southHopper();
+        eastHopper();
+        westHopper();
+    }
+
+    public void downHopper() {
+        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
+        hopper.setFacing(BlockFace.DOWN);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
+        cuboidList.add(pixelCuboid(6, 0, 6, 4, 4, 4));
+        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_FLOOR"));
+    }
+
+    public void northHopper() {
+        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
+        hopper.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
+        cuboidList.add(pixelCuboid(6, 4, 0, 4, 4, 4));
+        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_NORTH"));
+    }
+
+    public void southHopper() {
+        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
+        hopper.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
+        cuboidList.add(pixelCuboid(6, 4, 12, 4, 4, 4));
+        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_SOUTH"));
+    }
+
+    public void eastHopper() {
+        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
+        hopper.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
+        cuboidList.add(pixelCuboid(12, 4, 6, 4, 4, 4));
+        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_EAST"));
+    }
+
+    public void westHopper() {
+        Hopper hopper = (Hopper) Material.HOPPER.createBlockData();
+        hopper.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 10, 0, 16, 6, 16));
+        cuboidList.add(pixelCuboid(4, 4, 4, 8, 6, 8));
+        cuboidList.add(pixelCuboid(0, 4, 6, 4, 4, 4));
+        new BlockBoundingBox(hopper, cuboidList, createItem("LAUFBAU_BLOCK_HOPPER", Material.HOPPER, "LAUFBAU_CONNECTION_WEST"));
+    }
+}
@@ -0,0 +1,75 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Fence;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class IronBarBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        for (int nx = 0; nx < 2; nx++) {
+            for (int nz = 0; nz < 2; nz++) {
+                for (int px = 0; px < 2; px++) {
+                    for (int pz = 0; pz < 2; pz++) {
+                        Fence fence = (Fence) Material.IRON_BARS.createBlockData();
+                        List<String> lore = new ArrayList<>();
+                        List<Cuboid> cuboidList = new ArrayList<>();
+                        cuboidList.add(pixelCuboid(7, 0, 7, 2, 16, 2));
+                        if (nz == 1) {
+                            lore.add("LAUFBAU_CONNECTION_NORTH");
+                            fence.setFace(BlockFace.NORTH, true);
+                            cuboidList.add(pixelCuboid(7, 0, 0, 2, 16, 7));
+                        }
+                        if (pz == 1) {
+                            lore.add("LAUFBAU_CONNECTION_SOUTH");
+                            fence.setFace(BlockFace.SOUTH, true);
+                            cuboidList.add(pixelCuboid(7, 0, 9, 2, 16, 7));
+                        }
+                        if (nx == 1) {
+                            lore.add("LAUFBAU_CONNECTION_WEST");
+                            fence.setFace(BlockFace.WEST, true);
+                            cuboidList.add(pixelCuboid(0, 0, 7, 7, 16, 2));
+                        }
+                        if (px == 1) {
+                            lore.add("LAUFBAU_CONNECTION_EAST");
+                            fence.setFace(BlockFace.EAST, true);
+                            cuboidList.add(pixelCuboid(9, 0, 7, 7, 16, 2));
+                        }
+                        new BlockBoundingBox(fence, cuboidList, createItem("LAUFBAU_BLOCK_IRON_BARS", Material.IRON_BARS, lore.toArray(new String[0])));
+                    }
+                }
+            }
+        }
+    }
+}
@@ -0,0 +1,61 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.type.Lantern;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class LanternBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        lantern();
+        hangingLantern();
+    }
+
+    public void lantern() {
+        Lantern lantern = (Lantern) Material.LANTERN.createBlockData();
+        lantern.setHanging(false);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(5, 0, 5, 6, 7, 6));
+        cuboidList.add(pixelCuboid(6, 7, 6, 4, 2, 4));
+        new BlockBoundingBox(lantern, cuboidList, createItem("LAUFBAU_BLOCK_LANTERN", Material.LANTERN));
+    }
+
+    public void hangingLantern() {
+        Lantern lantern = (Lantern) Material.LANTERN.createBlockData();
+        lantern.setHanging(true);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(5, 1, 5, 6, 7, 6));
+        cuboidList.add(pixelCuboid(6, 8, 6, 4, 2, 4));
+        new BlockBoundingBox(lantern, cuboidList, createItem("LAUFBAU_BLOCK_LANTERN", Material.LANTERN, "LAUFBAU_HANGING"));
+    }
+}
@@ -0,0 +1,46 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.data.BlockData;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class LecternBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        BlockData blockData = Material.LECTERN.createBlockData();
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 2, 16));
+        cuboidList.add(pixelCuboid(4, 2, 4, 8, 12, 8));
+        new BlockBoundingBox(blockData, cuboidList, createItem("LAUFBAU_BLOCK_LECTERN", Material.LECTERN));
+    }
+}
@@ -0,0 +1,343 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Stairs;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class StairBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        straightBottomNorthStair();
+        straightBottomSouthStair();
+        straightBottomEastStair();
+        straightBottomWestStair();
+
+        straightTopNorthStair();
+        straightTopSouthStair();
+        straightTopEastStair();
+        straightTopWestStair();
+
+        outerLeftBottomNorthStair();
+        outerLeftBottomSouthStair();
+        outerLeftBottomEastStair();
+        outerLeftBottomWestStair();
+
+        outerLeftTopNorthStair();
+        outerLeftTopSouthStair();
+        outerLeftTopEastStair();
+        outerLeftTopWestStair();
+
+        innerLeftBottomNorthStair();
+        innerLeftBottomSouthStair();
+        innerLeftBottomEastStair();
+        innerLeftBottomWestStair();
+
+        innerLeftTopNorthStair();
+        innerLeftTopSouthStair();
+        innerLeftTopEastStair();
+        innerLeftTopWestStair();
+    }
+
+    public void straightBottomNorthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void straightBottomSouthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 8, 16, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void straightBottomEastStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(8, 8, 0, 8, 8, 16));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void straightBottomWestStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 0, 8, 8, 16));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void straightTopNorthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void straightTopSouthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 8, 16, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void straightTopEastStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(8, 0, 0, 8, 8, 16));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void straightTopWestStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.STRAIGHT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 0, 8, 8, 16));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_STRAIGHT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void outerLeftBottomNorthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void outerLeftBottomSouthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(8, 8, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void outerLeftBottomEastStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(8, 8, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void outerLeftBottomWestStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void outerLeftTopNorthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void outerLeftTopSouthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(8, 0, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void outerLeftTopEastStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(8, 0, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void outerLeftTopWestStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.OUTER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_OUTER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void innerLeftBottomNorthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 8));
+        cuboidList.add(pixelCuboid(0, 8, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void innerLeftBottomSouthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 8, 16, 8, 8));
+        cuboidList.add(pixelCuboid(8, 8, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void innerLeftBottomEastStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 8));
+        cuboidList.add(pixelCuboid(8, 8, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void innerLeftBottomWestStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.BOTTOM);
+        stairs.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 8, 8, 16, 8, 8));
+        cuboidList.add(pixelCuboid(0, 8, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_BOTTOM", "LAUFBAU_FACING_WEST"));
+    }
+
+    public void innerLeftTopNorthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.NORTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 8));
+        cuboidList.add(pixelCuboid(0, 0, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_NORTH"));
+    }
+
+    public void innerLeftTopSouthStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.SOUTH);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 8, 16, 8, 8));
+        cuboidList.add(pixelCuboid(8, 0, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_SOUTH"));
+    }
+
+    public void innerLeftTopEastStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.EAST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 0, 16, 8, 8));
+        cuboidList.add(pixelCuboid(8, 0, 8, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_EAST"));
+    }
+
+    public void innerLeftTopWestStair() {
+        Stairs stairs = (Stairs) Material.END_STONE_BRICK_STAIRS.createBlockData();
+        stairs.setShape(Stairs.Shape.INNER_LEFT);
+        stairs.setHalf(Stairs.Half.TOP);
+        stairs.setFacing(BlockFace.WEST);
+        List<Cuboid> cuboidList = new ArrayList<>();
+        cuboidList.add(pixelCuboid(0, 8, 0, 16, 8, 16));
+        cuboidList.add(pixelCuboid(0, 0, 8, 16, 8, 8));
+        cuboidList.add(pixelCuboid(0, 0, 0, 8, 8, 8));
+        new BlockBoundingBox(stairs, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_STAIRS", Material.END_STONE_BRICK_STAIRS, "LAUFBAU_SHAPE_INNER_LEFT", "LAUFBAU_HALF_TOP", "LAUFBAU_FACING_WEST"));
+    }
+}
@@ -0,0 +1,79 @@
+/*
+ *   This file is a part of the SteamWar software.
+ *
+ *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU Affero General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU Affero General Public License for more details.
+ *
+ *   You should have received a copy of the GNU Affero General Public License
+ *   along with this program.  If not, see <https://www.gnu.org/licenses/>.
+ */
+
+package de.steamwar.bausystem.features.slaves.laufbau.boundingboxes;
+
+import de.steamwar.bausystem.features.slaves.laufbau.BlockBoundingBox;
+import de.steamwar.bausystem.features.slaves.laufbau.BoundingBoxLoader;
+import de.steamwar.bausystem.features.slaves.laufbau.Cuboid;
+import de.steamwar.linkage.Linked;
+import org.bukkit.Material;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.type.Wall;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.createItem;
+import static de.steamwar.bausystem.features.slaves.laufbau.LaufbauUtils.pixelCuboid;
+
+@Linked
+public class WallBoundingBox implements BoundingBoxLoader {
+
+    @Override
+    public void load() {
+        v18();
+    }
+
+    private void v18() {
+        for (int nx = 0; nx < 2; nx++) {
+            for (int nz = 0; nz < 2; nz++) {
+                for (int px = 0; px < 2; px++) {
+                    for (int pz = 0; pz < 2; pz++) {
+                        Wall fence = (Wall) Material.END_STONE_BRICK_WALL.createBlockData();
+                        List<String> lore = new ArrayList<>();
+                        List<Cuboid> cuboidList = new ArrayList<>();
+                        cuboidList.add(pixelCuboid(4, 0, 4, 8, 24, 8));
+                        if (nz == 1) {
+                            lore.add("LAUFBAU_CONNECTION_NORTH");
+                            fence.setHeight(BlockFace.NORTH, Wall.Height.LOW);
+                            cuboidList.add(pixelCuboid(5, 0, 0, 6, 24, 4));
+                        }
+                        if (pz == 1) {
+                            lore.add("LAUFBAU_CONNECTION_SOUTH");
+                            fence.setHeight(BlockFace.SOUTH, Wall.Height.LOW);
+                            cuboidList.add(pixelCuboid(5, 0, 12, 6, 24, 4));
+                        }
+                        if (nx == 1) {
+                            lore.add("LAUFBAU_CONNECTION_WEST");
+                            fence.setHeight(BlockFace.WEST, Wall.Height.LOW);
+                            cuboidList.add(pixelCuboid(0, 0, 5, 4, 24, 6));
+                        }
+                        if (px == 1) {
+                            lore.add("LAUFBAU_CONNECTION_EAST");
+                            fence.setHeight(BlockFace.EAST, Wall.Height.LOW);
+                            cuboidList.add(pixelCuboid(12, 0, 5, 4, 24, 6));
+                        }
+                        new BlockBoundingBox(fence, cuboidList, createItem("LAUFBAU_BLOCK_END_STONE_BRICK_WALL", Material.END_STONE_BRICK_WALL, lore.toArray(new String[0])));
+                    }
+                }
+            }
+        }
+    }
+}
@@ -57,7 +57,7 @@ public class WorldEditListener implements Listener {

    private static final Set<String> commands = new HashSet<>();
    private static final Set<String> commandExclusions = new HashSet<>();
-    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r"};
+    private static final String[] shortcutCommands = {"//1", "//2", "//90", "//-90", "//180", "//p", "//c", "//flopy", "//floppy", "//flopyp", "//floppyp", "//u", "//r", "//download", "/download"};

    public static boolean isWorldEditCommand(String command) {
        for (String shortcut : shortcutCommands) {
@@ -37,6 +37,5 @@ tasks.register<DevServer>("DevBau21") {
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":BauSystem:shadowJar")
    dependsOn(":SchematicSystem:shadowJar")
-    dependsOn(":KotlinCore:shadowJar")
    template = "Bau21"
 }
@@ -18,6 +18,7 @@ dependencies {
    implementation("com.github.ajalt.clikt:clikt:5.0.3")
    implementation("com.github.ajalt.mordant:mordant:3.0.2")
    implementation(libs.logback)
+    implementation("org.yaml:snakeyaml:2.2")
    implementation("org.mariadb.jdbc:mariadb-java-client:3.3.1")

    implementation(libs.exposedCore)
@@ -14,9 +14,11 @@ import com.github.ajalt.clikt.parameters.types.file
 import com.github.ajalt.clikt.parameters.types.long
 import com.github.ajalt.clikt.parameters.types.path
 import com.sun.security.auth.module.UnixSystem
+import org.yaml.snakeyaml.Yaml
 import java.io.File
 import kotlin.io.path.absolute
 import kotlin.io.path.absolutePathString
+import kotlin.random.Random

 const val LOG4J_CONFIG = """<?xml version="1.0" encoding="UTF-8"?>
 <Configuration status="WARN" packages="com.mojang.util">
@@ -69,32 +71,42 @@ class DevCommand : CliktCommand("dev") {
    override fun run() {
        val args = mutableListOf<String>()

-        val serverDirectory = File(workingDir, server)
-        val serverDir =
-            if (serverDirectory.exists() && serverDirectory.isDirectory) serverDirectory else File(workingDir, server)
+        var serverDir = resolveServerDirectory(server)

        if (isVelocity(server)) {
            runServer(
                args, jvmArgs, listOf(
                    jar?.absolutePath
-                        ?: File("/jar/Velocity.jar").absolutePath
+                        ?: File("/jars/Velocity.jar").absolutePath
                ), serverDir
            )
        } else {
            setLogConfig(args)
            val version = findVersion(server)
                ?: throw CliktError("Unknown Server Version")
+            val gameModeTemplate = if (serverDir.isDirectory) null else loadGameModeTemplate(server)
+            if (gameModeTemplate != null) {
+                serverDir = gameModeTemplate.serverDir
+                args += "-Dconfig=$server.yml"
+            }
            val worldFile = world?.absolute()?.toFile()
-                ?: File(serverDir, "devtempworld")
-            val jarFile = jar?.absolutePath
+                ?: File(workingDir, "devtempworld")
+            var jarFile = jar?.absolutePath
                ?: additionalVersions[server]?.let { supportedVersionJars[it] }
                ?: supportedVersionJars[version]
                ?: throw CliktError("Unknown Server Version")
+            if (gameModeTemplate != null) {
+                jarFile = if (gameModeTemplate.spigot) {
+                    jarFile.replace("paper", "spigot")
+                } else {
+                    jarFile.replace("spigot", "paper")
+                }
+            }

            if (!worldFile.exists()) {
-                val templateFile = File(serverDir, "Bauwelt")
+                val templateFile = gameModeTemplate?.worldTemplate ?: File(serverDir, "Bauwelt")
                if (!templateFile.exists()) {
-                    throw CliktError("World Template not found!")
+                    throw CliktError("Could not find world template: ${templateFile.absolutePath}")
                }
                templateFile.copyRecursively(worldFile)
            }
@@ -123,6 +135,12 @@ class DevCommand : CliktCommand("dev") {
        }
    }

+    data class GameModeTemplate(
+        val serverDir: File,
+        val worldTemplate: File,
+        val spigot: Boolean
+    )
+
    val jvmDefaultParams = arrayOf(
        "-Xmx1G",
        "-Xgc:excessiveGCratio=80",
@@ -165,6 +183,41 @@ class DevCommand : CliktCommand("dev") {
    fun isVelocity(server: String): Boolean =
        server.endsWith("Velocity")

+    fun resolveServerDirectory(server: String): File {
+        val localServer = File(workingDir, server)
+        if (localServer.isDirectory) {
+            return localServer
+        }
+        return File("/servers", server)
+    }
+
+    fun loadGameModeTemplate(server: String): GameModeTemplate? {
+        val configFile = File("/configs/GameModes/$server.yml")
+        if (!configFile.exists()) {
+            throw CliktError("Server/GameMode not found")
+        }
+
+        val document = configFile.reader().use { reader ->
+            Yaml().load<Map<String, Any?>>(reader)
+        } ?: throw CliktError("GameMode config is empty: ${configFile.absolutePath}")
+        val serverConfig = document["Server"] as? Map<*, *>
+            ?: throw CliktError("GameMode config is missing Server section: ${configFile.absolutePath}")
+        val folder = serverConfig["Folder"] as? String
+            ?: throw CliktError("GameMode config is missing Server.Folder: ${configFile.absolutePath}")
+        val maps = (serverConfig["Maps"] as? List<*>)
+            ?.filterIsInstance<String>()
+            ?.takeIf { it.isNotEmpty() }
+            ?: throw CliktError("GameMode config is missing Server.Maps: ${configFile.absolutePath}")
+
+        val serverDir = File("/servers", folder)
+        val worldTemplate = File(File(serverDir, "arenas"), maps[Random.nextInt(maps.size)])
+        return GameModeTemplate(
+            serverDir = serverDir,
+            worldTemplate = worldTemplate,
+            spigot = serverConfig["Spigot"] == true
+        )
+    }
+
    fun setLogConfig(args: MutableList<String>) {
        args += "-DlogPath=${workingDir.absolutePath}/logs"
        args += "-Dlog4j.configurationFile=${log4jConfig.absolutePath}"
@@ -190,4 +243,4 @@ class DevCommand : CliktCommand("dev") {
        Runtime.getRuntime().addShutdownHook(Thread { if (process.isAlive) process.destroyForcibly() })
        process.waitFor()
    }
-}
+}
@@ -1,7 +1,7 @@
 /*
 *   This file is a part of the SteamWar software.
 *
- *   Copyright (C) 2025 SteamWar.de-Serverteam
+ *   Copyright (C) 2026 SteamWar.de-Serverteam
 *
 *   This program is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Affero General Public License as published by
@@ -31,17 +31,16 @@ import de.steamwar.linkage.Linked;
 import net.md_5.bungee.api.ChatMessageType;
 import org.bukkit.GameMode;
 import org.bukkit.Material;
+import org.bukkit.Tag;
 import org.bukkit.block.Block;
 import org.bukkit.block.data.type.Dispenser;
+import org.bukkit.block.data.type.DriedGhast;
 import org.bukkit.entity.Player;
 import org.bukkit.entity.TNTPrimed;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockDispenseEvent;
-import org.bukkit.event.block.BlockFromToEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.block.*;
 import org.bukkit.event.entity.EntityExplodeEvent;
 import org.bukkit.event.entity.FoodLevelChangeEvent;
 import org.bukkit.event.entity.PlayerDeathEvent;
@@ -258,4 +257,16 @@ public class Permanent implements Listener {
        event.setCancelled(true);
        FightSystem.getMessage().sendPrefixless("NO_BLOCK_BREAK", event.getPlayer(), ChatMessageType.ACTION_BAR);
    }
+
+    /**
+     * Prevents Dried Ghast from spawning and plants from growing
+     */
+    @EventHandler
+    public void onBlockGrow(BlockGrowEvent event) {
+        var type = event.getBlock().getType();
+
+        if (event.getBlock().getBlockData() instanceof DriedGhast || Tag.CROPS.isTagged(type) || Tag.SAPLINGS.isTagged(type)) {
+            event.setCancelled(true);
+        }
+    }
 }
@@ -38,11 +38,11 @@ widener {
    fromCatalog(libs.paperapi)
 }

-tasks.register<DevServer>("DevLobby20") {
+tasks.register<DevServer>("DevLobby") {
    group = "run"
-    description = "Run a 1.20 Dev Lobby"
+    description = "Run a Dev Lobby"
    dependsOn(":SpigotCore:shadowJar")
    dependsOn(":LobbySystem:jar")
-    template = "Lobby20"
+    template = "Lobby21"
    worldName = "Lobby"
 }
@@ -59,8 +59,6 @@ dependencies {
    compileOnly(libs.netty)
    compileOnly(libs.brigadier)
    compileOnly(libs.fastutil)
-
-    implementation(libs.anvilgui)
 }

 widener {
@@ -0,0 +1,890 @@
+package net.wesjd.anvilgui;
+
+import lombok.Getter;
+import lombok.NonNull;
+import net.md_5.bungee.api.chat.BaseComponent;
+import net.wesjd.anvilgui.version.VersionWrapper;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.*;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.plugin.Plugin;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.Executor;
+import java.util.function.BiConsumer;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.logging.Level;
+
+/**
+ * An anvil gui, used for gathering a user's input
+ *
+ * @author Wesley Smith
+ * @since 1.0
+ */
+public class AnvilGUI {
+
+    /**
+     * The local {@link VersionWrapper} object for the server's version
+     */
+    private static final VersionWrapper WRAPPER = VersionWrapper.INSTANCE;
+
+    /**
+     * The variable containing an item with air. Used when the item would be null.
+     * To keep the heap clean, this object only gets iniziaised once
+     */
+    private static final ItemStack AIR = new ItemStack(Material.AIR);
+    /**
+     * If the given ItemStack is null, return an air ItemStack, otherwise return the given ItemStack
+     *
+     * @param stack The ItemStack to check
+     * @return air or the given ItemStack
+     */
+    private static ItemStack itemNotNull(ItemStack stack) {
+        return stack == null ? AIR : stack;
+    }
+
+    /**
+     * The {@link Plugin} that this anvil GUI is associated with
+     */
+    private final Plugin plugin;
+    /**
+     * The player who has the GUI open
+     */
+    private final Player player;
+    /**
+     * An {@link Executor} that executes tasks on the main server thread
+     */
+    private final Executor mainThreadExecutor;
+    /**
+     * The title of the anvil inventory
+     */
+    private final Object titleComponent;
+    /**
+     * The initial contents of the inventory
+     */
+    private final ItemStack[] initialContents;
+    /**
+     * A state that decides where the anvil GUI is able to get closed by the user
+     */
+    private final boolean preventClose;
+
+    /**
+     * A set of slot numbers that are permitted to be interacted with by the user. An interactable
+     * slot is one that is able to be minipulated by the player, i.e. clicking and picking up an item,
+     * placing in a new one, etc.
+     */
+    private final Set<Integer> interactableSlots;
+
+    /** An {@link Consumer} that is called when the anvil GUI is close */
+    private final Consumer<StateSnapshot> closeListener;
+    /** A flag that decides whether the async click handler can be run concurrently */
+    private final boolean concurrentClickHandlerExecution;
+    /** An {@link BiFunction} that is called when a slot is clicked */
+    private final ClickHandler clickHandler;
+
+    /**
+     * The container id of the inventory, used for NMS methods
+     */
+    private int containerId;
+
+    /**
+     * The inventory that is used on the Bukkit side of things
+     */
+    @Getter
+    private Inventory inventory;
+    /**
+     * The listener holder class
+     */
+    private final ListenUp listener = new ListenUp();
+
+    /**
+     * Represents the state of the inventory being open
+     */
+    private boolean open;
+
+    /**
+     * The actual container backing the Anvil GUI
+     */
+    private VersionWrapper.AnvilContainerWrapper container;
+
+    /**
+     * Create an AnvilGUI
+     *
+     * @param plugin              A {@link org.bukkit.plugin.java.JavaPlugin} instance
+     * @param player              The {@link Player} to open the inventory for
+     * @param mainThreadExecutor  An {@link Executor} that executes on the main server thread
+     * @param titleComponent      What to have the text already set to
+     * @param initialContents     The initial contents of the inventory
+     * @param preventClose        Whether to prevent the inventory from closing
+     * @param closeListener       A {@link Consumer} when the inventory closes
+     * @param concurrentClickHandlerExecution Flag to allow concurrent execution of the click handler
+     * @param clickHandler        A {@link ClickHandler} that is called when the player clicks a slot
+     */
+    private AnvilGUI(
+            Plugin plugin,
+            Player player,
+            Executor mainThreadExecutor,
+            Object titleComponent,
+            ItemStack[] initialContents,
+            boolean preventClose,
+            Set<Integer> interactableSlots,
+            Consumer<StateSnapshot> closeListener,
+            boolean concurrentClickHandlerExecution,
+            ClickHandler clickHandler) {
+        this.plugin = plugin;
+        this.player = player;
+        this.mainThreadExecutor = mainThreadExecutor;
+        this.titleComponent = titleComponent;
+        this.initialContents = initialContents;
+        this.preventClose = preventClose;
+        this.interactableSlots = Collections.unmodifiableSet(interactableSlots);
+        this.closeListener = closeListener;
+        this.concurrentClickHandlerExecution = concurrentClickHandlerExecution;
+        this.clickHandler = clickHandler;
+    }
+
+    /**
+     * Opens the anvil GUI
+     */
+    private void openInventory() {
+        Bukkit.getPluginManager().registerEvents(listener, plugin);
+
+        container = WRAPPER.newContainerAnvil(player, titleComponent);
+
+        inventory = container.getBukkitInventory();
+        // We need to use setItem instead of setContents because a Minecraft ContainerAnvil
+        // contains two separate inventories: the result inventory and the ingredients inventory.
+        // The setContents method only updates the ingredients inventory unfortunately,
+        // but setItem handles the index going into the result inventory.
+        for (int i = 0; i < initialContents.length; i++) {
+            inventory.setItem(i, initialContents[i]);
+        }
+
+        containerId = WRAPPER.getNextContainerId(player, container);
+        WRAPPER.handleInventoryCloseEvent(player);
+        WRAPPER.sendPacketOpenWindow(player, containerId, titleComponent);
+        WRAPPER.setActiveContainer(player, container);
+        WRAPPER.setActiveContainerId(container, containerId);
+        WRAPPER.addActiveContainerSlotListener(container, player);
+
+        open = true;
+    }
+
+    /**
+     * Closes the inventory if it's open.
+     */
+    public void closeInventory() {
+        closeInventory(true);
+    }
+
+    /**
+     * Closes the inventory if it's open, only sending the close inventory packets if the arg is true
+     *
+     * @param sendClosePacket Whether to send the close inventory event, packet, etc
+     */
+    private void closeInventory(boolean sendClosePacket) {
+        if (!open) {
+            return;
+        }
+
+        open = false;
+
+        HandlerList.unregisterAll(listener);
+
+        inventory = container.getBukkitInventory();
+        // We need to use setItem instead of setContents because a Minecraft ContainerAnvil
+        // contains two separate inventories: the result inventory and the ingredients inventory.
+        // The setContents method only updates the ingredients inventory unfortunately,
+        // but setItem handles the index going into the result inventory.
+        for (int i = 0; i < initialContents.length; i++) {
+            inventory.setItem(i, new ItemStack(Material.AIR));
+        }
+
+        if (sendClosePacket) {
+            WRAPPER.handleInventoryCloseEvent(player);
+            WRAPPER.setActiveContainerDefault(player);
+            WRAPPER.sendPacketCloseWindow(player, containerId);
+        }
+
+        if (closeListener != null) {
+            closeListener.accept(StateSnapshot.fromAnvilGUI(this));
+        }
+    }
+
+    /**
+     * Updates the title of the AnvilGUI to the new one.
+     *
+     * @param literalTitle The title to use as literal text
+     * @param preserveRenameText Whether to preserve the entered rename text
+     * @throws IllegalArgumentException when literalTitle is null
+     * @see Builder#title(String)
+     */
+    public void setTitle(@NonNull String literalTitle, boolean preserveRenameText) {
+        setTitle(WRAPPER.literalChatComponent(literalTitle), preserveRenameText);
+    }
+
+    /**
+     * Updates the title of the AnvilGUI to the new one.
+     *
+     * @param json The json used to parse into a rich chat component
+     * @param preserveRenameText Whether to preserve the entered rename text
+     * @throws IllegalArgumentException when json is null
+     * @see Builder#jsonTitle(String)
+     */
+    public void setJsonTitle(@NonNull String json, boolean preserveRenameText) {
+        setTitle(WRAPPER.jsonChatComponent(json), preserveRenameText);
+    }
+
+    /**
+     * Updates the title of the AnvilGUI to the new one.
+     *
+     * @param title The title as a NMS ChatComponent
+     * @param preserveRenameText Whether to preserve the entered rename text
+     */
+    private void setTitle(Object title, boolean preserveRenameText) {
+        String renameText = container.getRenameText();
+        WRAPPER.sendPacketOpenWindow(player, containerId, title);
+        if (preserveRenameText) {
+            // The renameText field is marked as @Nullable in newer versions
+            container.setRenameText(renameText == null ? "" : renameText);
+        }
+    }
+
+    /**
+     * Simply holds the listeners for the GUI
+     */
+    private class ListenUp implements Listener {
+
+        /**
+         * Boolean storing the running status of the latest click handler to prevent double execution.
+         * All accesses to this boolean will be from the main server thread, except for the rare event
+         * that the plugin is disabled and the mainThreadExecutor throws an exception
+         */
+        private boolean clickHandlerRunning = false;
+
+        @EventHandler
+        public void onInventoryClick(InventoryClickEvent event) {
+            if (!event.getInventory().equals(inventory)) {
+                return;
+            }
+
+            final int rawSlot = event.getRawSlot();
+            // ignore items dropped outside the window
+            if (rawSlot == -999) return;
+
+            final Player clicker = (Player) event.getWhoClicked();
+            final Inventory clickedInventory = event.getClickedInventory();
+
+            if (clickedInventory != null) {
+                if (clickedInventory.equals(clicker.getInventory())) {
+                    // prevent players from merging items from the anvil inventory
+                    if (event.getClick().equals(ClickType.DOUBLE_CLICK)) {
+                        event.setCancelled(true);
+                        return;
+                    }
+                    // prevent shift moving items from players inv to the anvil inventory
+                    if (event.isShiftClick()) {
+                        event.setCancelled(true);
+                        return;
+                    }
+                }
+                // prevent players from swapping items in the anvil gui
+                if ((event.getCursor() != null && event.getCursor().getType() != Material.AIR)
+                        && !interactableSlots.contains(rawSlot)
+                        && event.getClickedInventory().equals(inventory)) {
+                    event.setCancelled(true);
+                    return;
+                }
+            }
+
+            if (rawSlot < 3 && rawSlot >= 0 || event.getAction().equals(InventoryAction.MOVE_TO_OTHER_INVENTORY)) {
+                event.setCancelled(true);
+                if (clickHandlerRunning && !concurrentClickHandlerExecution) {
+                    // A click handler is running, don't launch another one
+                    return;
+                }
+
+                final CompletableFuture<List<ResponseAction>> actionsFuture =
+                        clickHandler.apply(rawSlot, StateSnapshot.fromAnvilGUI(AnvilGUI.this));
+
+                final Consumer<List<ResponseAction>> actionsConsumer = actions -> {
+                    for (final ResponseAction action : actions) {
+                        action.accept(AnvilGUI.this, clicker);
+                    }
+                };
+
+                if (actionsFuture.isDone()) {
+                    // Fast-path without scheduling if clickHandler is performed in sync
+                    // Because the future is already completed, .join() will not block the server thread
+                    actionsFuture.thenAccept(actionsConsumer).join();
+                } else {
+                    clickHandlerRunning = true;
+                    // If the plugin is disabled and the Executor throws an exception, the exception will be passed to
+                    // the .handle method
+                    actionsFuture
+                            .thenAcceptAsync(actionsConsumer, mainThreadExecutor)
+                            .handle((results, exception) -> {
+                                if (exception != null) {
+                                    plugin.getLogger()
+                                            .log(
+                                                    Level.SEVERE,
+                                                    "An exception occurred in the AnvilGUI clickHandler",
+                                                    exception);
+                                }
+                                // Whether an exception occurred or not, set running to false
+                                clickHandlerRunning = false;
+                                return null;
+                            });
+                }
+            }
+        }
+
+        @EventHandler
+        public void onInventoryDrag(InventoryDragEvent event) {
+            if (event.getInventory().equals(inventory)) {
+                event.setCancelled(true);
+            }
+        }
+
+        @EventHandler
+        public void onInventoryClose(InventoryCloseEvent event) {
+            if (open && event.getInventory().equals(inventory)) {
+                closeInventory(false);
+                if (preventClose) {
+                    mainThreadExecutor.execute(AnvilGUI.this::openInventory);
+                }
+            }
+        }
+    }
+
+    /** A builder class for an {@link AnvilGUI} object */
+    public static class Builder {
+
+        /** An {@link Executor} that executes tasks on the main server thread */
+        private Executor mainThreadExecutor;
+        /** An {@link Consumer} that is called when the anvil GUI is close */
+        private Consumer<StateSnapshot> closeListener;
+        /** A flag that decides whether the async click handler can be run concurrently */
+        private boolean concurrentClickHandlerExecution = false;
+        /** An {@link Function} that is called when a slot in the inventory has been clicked */
+        private ClickHandler clickHandler;
+        /** A state that decides where the anvil GUI is able to be closed by the user */
+        private boolean preventClose = false;
+        /** A set of integers containing the slot numbers that should be modifiable by the user. */
+        private Set<Integer> interactableSlots = Collections.emptySet();
+        /** The {@link Plugin} that this anvil GUI is associated with */
+        private Plugin plugin;
+        /** The text that will be displayed to the user */
+        private Object titleComponent = WRAPPER.literalChatComponent("Repair & Name");
+        /** The starting text on the item */
+        private String itemText;
+        /** An {@link ItemStack} to be put in the left input slot */
+        private ItemStack itemLeft;
+        /** An {@link ItemStack} to be put in the right input slot */
+        private ItemStack itemRight;
+        /** An {@link ItemStack} to be placed in the output slot */
+        private ItemStack itemOutput;
+
+        /**
+         * Set a custom main server thread executor. Useful for plugins targeting Folia.
+         *
+         * @param executor The executor to run tasks on
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException when the executor is null
+         */
+        public Builder mainThreadExecutor(@NonNull Executor executor) {
+            this.mainThreadExecutor = executor;
+            return this;
+        }
+
+        /**
+         * Prevents the closing of the anvil GUI by the user
+         *
+         * @return The {@link Builder} instance
+         */
+        public Builder preventClose() {
+            preventClose = true;
+            return this;
+        }
+
+        /**
+         * Permit the user to modify (take items in and out) the slot numbers provided.
+         *
+         * @param slots A varags param for the slot numbers. You can avoid relying on magic constants by using
+         *              the {@link AnvilGUI.Slot} class.
+         * @return The {@link Builder} instance
+         */
+        public Builder interactableSlots(int... slots) {
+            final Set<Integer> newValue = new HashSet<>();
+            for (int slot : slots) {
+                newValue.add(slot);
+            }
+            interactableSlots = newValue;
+            return this;
+        }
+
+        /**
+         * Listens for when the inventory is closed
+         *
+         * @param closeListener An {@link Consumer} that is called when the anvil GUI is closed
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException when the closeListener is null
+         */
+        public Builder onClose(@NonNull Consumer<StateSnapshot> closeListener) {
+            this.closeListener = closeListener;
+            return this;
+        }
+
+        /**
+         * Do an action when a slot is clicked in the inventory
+         * <p>
+         * The ClickHandler is only called when the previous execution of the ClickHandler has finished.
+         * To alter this behaviour use {@link #allowConcurrentClickHandlerExecution()}
+         *
+         * @param clickHandler A {@link ClickHandler} that is called when the user clicks a slot. The
+         *                     {@link Integer} is the slot number corresponding to {@link Slot}, the
+         *                     {@link StateSnapshot} contains information about the current state of the anvil,
+         *                     and the response is a {@link CompletableFuture} that will eventually return a
+         *                     list of {@link ResponseAction} to execute in the order that they are supplied.
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException when the function supplied is null
+         */
+        public Builder onClickAsync(@NonNull ClickHandler clickHandler) {
+            this.clickHandler = clickHandler;
+            return this;
+        }
+
+        /**
+         * By default, the {@link #onClickAsync(ClickHandler) async click handler} will not run concurrently
+         * and instead wait for the previous {@link CompletableFuture} to finish before executing it again.
+         * <p>
+         * If this trait is desired, it can be enabled by calling this method but may lead to inconsistent
+         * behaviour if not handled properly.
+         *
+         * @return The {@link Builder} instance
+         */
+        public Builder allowConcurrentClickHandlerExecution() {
+            this.concurrentClickHandlerExecution = true;
+            return this;
+        }
+
+        /**
+         * Do an action when a slot is clicked in the inventory
+         *
+         * @param clickHandler A {@link BiFunction} that is called when the user clicks a slot. The
+         *                     {@link Integer} is the slot number corresponding to {@link Slot}, the
+         *                     {@link StateSnapshot} contains information about the current state of the anvil,
+         *                     and the response is a list of {@link ResponseAction} to execute in the order
+         *                     that they are supplied.
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException when the function supplied is null
+         */
+        public Builder onClick(@NonNull BiFunction<Integer, StateSnapshot, List<ResponseAction>> clickHandler) {
+            this.clickHandler =
+                    (slot, stateSnapshot) -> CompletableFuture.completedFuture(clickHandler.apply(slot, stateSnapshot));
+            return this;
+        }
+
+        /**
+         * Sets the plugin for the {@link AnvilGUI}
+         *
+         * @param plugin The {@link Plugin} this anvil GUI is associated with
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException if the plugin is null
+         */
+        public Builder plugin(@NonNull Plugin plugin) {
+            this.plugin = plugin;
+            return this;
+        }
+
+        /**
+         * Sets the initial item-text that is displayed to the user.
+         * <br><br>
+         * If the usage of Adventure Components is desired, you must create an item, set the displayname of it
+         * and put it into the AnvilGUI via {@link #itemLeft(ItemStack)} manually.
+         *
+         * @param text The initial name of the item in the anvil
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException if the text is null
+         */
+        public Builder text(@NonNull String text) {
+            this.itemText = text;
+            return this;
+        }
+
+        /**
+         * Sets the AnvilGUI title that is to be displayed to the user.
+         * <br>
+         * The provided title will be treated as literal text.
+         *
+         * @param title The title that is to be displayed to the user
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException if the title is null
+         */
+        public Builder title(@NonNull String title) {
+            this.titleComponent = WRAPPER.literalChatComponent(title);
+            return this;
+        }
+
+        /**
+         * Sets the AnvilGUI title that is to be displayed to the user.
+         * <br>
+         * The provided json will be parsed into rich chat components.
+         *
+         * @param json The title that is to be displayed to the user
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException if the title is null
+         * @see net.md_5.bungee.chat.ComponentSerializer#toString(BaseComponent)
+         */
+        public Builder jsonTitle(@NonNull String json) {
+            this.titleComponent = WRAPPER.jsonChatComponent(json);
+            return this;
+        }
+
+        /**
+         * Sets the {@link ItemStack} to be put in the first slot
+         *
+         * @param item The {@link ItemStack} to be put in the first slot
+         * @return The {@link Builder} instance
+         * @throws IllegalArgumentException if the {@link ItemStack} is null
+         */
+        public Builder itemLeft(@NonNull ItemStack item) {
+            this.itemLeft = item;
+            return this;
+        }
+
+        /**
+         * Sets the {@link ItemStack} to be put in the second slot
+         *
+         * @param item The {@link ItemStack} to be put in the second slot
+         * @return The {@link Builder} instance
+         */
+        public Builder itemRight(ItemStack item) {
+            this.itemRight = item;
+            return this;
+        }
+
+        /**
+         * Sets the {@link ItemStack} to be put in the output slot
+         *
+         * @param item The {@link ItemStack} to be put in the output slot
+         * @return The {@link Builder} instance
+         */
+        public Builder itemOutput(ItemStack item) {
+            this.itemOutput = item;
+            return this;
+        }
+
+        /**
+         * Creates the anvil GUI and opens it for the player
+         *
+         * @param player The {@link Player} the anvil GUI should open for
+         * @return The {@link AnvilGUI} instance from this builder
+         * @throws IllegalArgumentException when the onClick function, plugin, or player is null
+         */
+        public AnvilGUI open(@NonNull Player player) {
+            if (plugin == null) {
+                throw new IllegalStateException("An AnvilGUI plugin has not been set!");
+            }
+            if (clickHandler == null) {
+                throw new IllegalStateException("An AnvilGUI clickHandler has not been set!");
+            }
+
+            if (itemText != null) {
+                if (itemLeft == null) {
+                    itemLeft = new ItemStack(Material.PAPER);
+                }
+
+                ItemMeta paperMeta = itemLeft.getItemMeta();
+                paperMeta.setDisplayName(itemText);
+                itemLeft.setItemMeta(paperMeta);
+            }
+
+            // If no executor is specified, execute all tasks with the BukkitScheduler
+            if (mainThreadExecutor == null) {
+                mainThreadExecutor = task -> Bukkit.getScheduler().runTask(plugin, task);
+            }
+
+            final AnvilGUI anvilGUI = new AnvilGUI(
+                    plugin,
+                    player,
+                    mainThreadExecutor,
+                    titleComponent,
+                    new ItemStack[] {itemLeft, itemRight, itemOutput},
+                    preventClose,
+                    interactableSlots,
+                    closeListener,
+                    concurrentClickHandlerExecution,
+                    clickHandler);
+            anvilGUI.openInventory();
+            return anvilGUI;
+        }
+    }
+
+    /**
+     * A handler that is called when the user clicks a slot. The
+     * {@link Integer} is the slot number corresponding to {@link Slot}, the
+     * {@link StateSnapshot} contains information about the current state of the anvil,
+     * and the response is a {@link CompletableFuture} that will eventually return a
+     * list of {@link ResponseAction} to execute in the order that they are supplied.
+     */
+    @FunctionalInterface
+    public interface ClickHandler extends BiFunction<Integer, StateSnapshot, CompletableFuture<List<ResponseAction>>> {}
+
+    /** An action to run in response to a player clicking the output slot in the GUI. This interface is public
+     * and permits you, the developer, to add additional response features easily to your custom AnvilGUIs. */
+    @FunctionalInterface
+    public interface ResponseAction extends BiConsumer<AnvilGUI, Player> {
+
+        /**
+         * Replace the input text box value with the provided text value.
+         *
+         * Before using this method, it must be verified by the caller that items are either in
+         * {@link Slot#INPUT_LEFT} or {@link Slot#OUTPUT} present.
+         *
+         * @param text The text to write in the input box
+         * @return The {@link ResponseAction} to achieve the text replacement
+         * @throws IllegalArgumentException when the text is null
+         * @throws IllegalStateException when the slots {@link Slot#INPUT_LEFT} and {@link Slot#OUTPUT} are <code>null</code>
+         */
+        static ResponseAction replaceInputText(@NonNull String text) {
+            return (anvilgui, player) -> {
+                ItemStack item = anvilgui.getInventory().getItem(Slot.OUTPUT);
+                if (item == null) {
+                    // Fallback on left input slot if player hasn't typed anything yet
+                    item = anvilgui.getInventory().getItem(Slot.INPUT_LEFT);
+                }
+                if (item == null) {
+                    throw new IllegalStateException(
+                            "replaceInputText can only be used if slots OUTPUT or INPUT_LEFT are not empty");
+                }
+
+                final ItemStack cloned = item.clone();
+                final ItemMeta meta = cloned.getItemMeta();
+                meta.setDisplayName(text);
+                cloned.setItemMeta(meta);
+                anvilgui.getInventory().setItem(Slot.INPUT_LEFT, cloned);
+            };
+        }
+
+        /**
+         * Updates the title of the AnvilGUI to the new one.
+         *
+         * @param literalTitle The title to use as literal text
+         * @param preserveRenameText Whether to preserve the entered rename text
+         * @throws IllegalArgumentException when literalTitle is null
+         * @see Builder#title(String)
+         */
+        static ResponseAction updateTitle(@NonNull String literalTitle, boolean preserveRenameText) {
+            return (anvilGUI, player) -> anvilGUI.setTitle(literalTitle, preserveRenameText);
+        }
+
+        /**
+         * Updates the title of the AnvilGUI to the new one.
+         *
+         * @param json The json used to parse into a rich chat component
+         * @param preserveRenameText Whether to preserve the entered rename text
+         * @throws IllegalArgumentException when json is null
+         * @see Builder#jsonTitle(String)
+         */
+        static ResponseAction updateJsonTitle(@NonNull String json, boolean preserveRenameText) {
+            return (anvilGUI, player) -> anvilGUI.setJsonTitle(json, preserveRenameText);
+        }
+
+        /**
+         * Open another inventory
+         * @param otherInventory The inventory to open
+         * @return The {@link ResponseAction} to achieve the inventory open
+         * @throws IllegalArgumentException when the otherInventory is null
+         */
+        static ResponseAction openInventory(@NonNull Inventory otherInventory) {
+            return (anvilgui, player) -> player.openInventory(otherInventory);
+        }
+
+        /**
+         * Close the AnvilGUI
+         * @return The {@link ResponseAction} to achieve closing the AnvilGUI
+         */
+        static ResponseAction close() {
+            return (anvilgui, player) -> anvilgui.closeInventory();
+        }
+
+        /**
+         * Run the provided runnable
+         * @param runnable The runnable to run
+         * @return The {@link ResponseAction} to achieve running the runnable
+         * @throws IllegalArgumentException when the runnable is null
+         */
+        static ResponseAction run(@NonNull Runnable runnable) {
+            return (anvilgui, player) -> runnable.run();
+        }
+    }
+
+    /**
+     * Represents a response when the player clicks the output item in the anvil GUI
+     * @deprecated Since 1.6.2, use {@link ResponseAction}
+     */
+    @Deprecated
+    public static class Response {
+        /**
+         * Returns an {@link Response} object for when the anvil GUI is to close
+         * @return An {@link Response} object for when the anvil GUI is to display text to the user
+         * @deprecated Since 1.6.2, use {@link ResponseAction#close()}
+         */
+        public static List<ResponseAction> close() {
+            return Arrays.asList(ResponseAction.close());
+        }
+
+        /**
+         * Returns an {@link Response} object for when the anvil GUI is to display text to the user
+         *
+         * @param text The text that is to be displayed to the user
+         * @return A list containing the {@link ResponseAction} for legacy compat
+         * @deprecated Since 1.6.2, use {@link ResponseAction#replaceInputText(String)}
+         */
+        public static List<ResponseAction> text(String text) {
+            return Arrays.asList(ResponseAction.replaceInputText(text));
+        }
+
+        /**
+         * Returns an {@link Response} object for when the GUI should open the provided inventory
+         *
+         * @param inventory The inventory to open
+         * @return A list containing the {@link ResponseAction} for legacy compat
+         * @deprecated Since 1.6.2, use {@link ResponseAction#openInventory(Inventory)}
+         */
+        public static List<ResponseAction> openInventory(Inventory inventory) {
+            return Arrays.asList(ResponseAction.openInventory(inventory));
+        }
+    }
+
+    /**
+     * Class wrapping the magic constants of slot numbers in an anvil GUI
+     */
+    public static class Slot {
+
+        private static final int[] values = new int[] {Slot.INPUT_LEFT, Slot.INPUT_RIGHT, Slot.OUTPUT};
+
+        /**
+         * The slot on the far left, where the first input is inserted. An {@link ItemStack} is always inserted
+         * here to be renamed
+         */
+        public static final int INPUT_LEFT = 0;
+        /**
+         * Not used, but in a real anvil you are able to put the second item you want to combine here
+         */
+        public static final int INPUT_RIGHT = 1;
+        /**
+         * The output slot, where an item is put when two items are combined from {@link #INPUT_LEFT} and
+         * {@link #INPUT_RIGHT} or {@link #INPUT_LEFT} is renamed
+         */
+        public static final int OUTPUT = 2;
+
+        /**
+         * Get all anvil slot values
+         *
+         * @return The array containing all possible anvil slots
+         */
+        public static int[] values() {
+            return values;
+        }
+    }
+
+    /** Represents a snapshot of the state of an AnvilGUI */
+    public static final class StateSnapshot {
+
+        /**
+         * Create an {@link StateSnapshot} from the current state of an {@link AnvilGUI}
+         * @param anvilGUI The instance to take the snapshot of
+         * @return The snapshot
+         */
+        private static StateSnapshot fromAnvilGUI(AnvilGUI anvilGUI) {
+            final Inventory inventory = anvilGUI.getInventory();
+            return new StateSnapshot(
+                    itemNotNull(inventory.getItem(Slot.INPUT_LEFT)).clone(),
+                    itemNotNull(inventory.getItem(Slot.INPUT_RIGHT)).clone(),
+                    itemNotNull(inventory.getItem(Slot.OUTPUT)).clone(),
+                    anvilGUI.player);
+        }
+
+        /**
+         * The {@link ItemStack} in the anvilGui slots
+         */
+        private final ItemStack leftItem, rightItem, outputItem;
+
+        /**
+         * The {@link Player} that clicked the output slot
+         */
+        private final Player player;
+
+        /**
+         * The event parameter constructor
+         * @param leftItem The left item in the combine slot of the anvilGUI
+         * @param rightItem The right item in the combine slot of the anvilGUI
+         * @param outputItem The item that would have been outputted, when the items would have been combined
+         * @param player The player that clicked the output slot
+         */
+        public StateSnapshot(ItemStack leftItem, ItemStack rightItem, ItemStack outputItem, Player player) {
+            this.leftItem = leftItem;
+            this.rightItem = rightItem;
+            this.outputItem = outputItem;
+            this.player = player;
+        }
+
+        /**
+         * It returns the item in the left combine slot of the gui
+         *
+         * @return The leftItem
+         */
+        public ItemStack getLeftItem() {
+            return leftItem;
+        }
+
+        /**
+         * It returns the item in the right combine slot of the gui
+         *
+         * @return The rightItem
+         */
+        public ItemStack getRightItem() {
+            return rightItem;
+        }
+
+        /**
+         * It returns the output item that would have been the result
+         * by combining the left and right one
+         *
+         * @return The outputItem
+         */
+        public ItemStack getOutputItem() {
+            return outputItem;
+        }
+
+        /**
+         * It returns the player that clicked onto the output slot
+         *
+         * @return The player
+         */
+        public Player getPlayer() {
+            return player;
+        }
+
+        /**
+         * It returns the text the player typed into the rename field
+         *
+         * @return The text of the rename field
+         */
+        public String getText() {
+            return outputItem.hasItemMeta() ? outputItem.getItemMeta().getDisplayName() : "";
+        }
+    }
+}
@@ -0,0 +1,151 @@
+package net.wesjd.anvilgui.version;
+
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.component.DataComponents;
+import net.minecraft.network.chat.Component;
+import net.minecraft.network.protocol.game.ClientboundContainerClosePacket;
+import net.minecraft.network.protocol.game.ClientboundOpenScreenPacket;
+import net.minecraft.network.protocol.game.ClientboundSetExperiencePacket;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.inventory.AnvilMenu;
+import net.minecraft.world.inventory.ContainerLevelAccess;
+import net.minecraft.world.inventory.MenuType;
+import net.minecraft.world.inventory.Slot;
+import org.bukkit.craftbukkit.CraftWorld;
+import org.bukkit.craftbukkit.entity.CraftPlayer;
+import org.bukkit.craftbukkit.event.CraftEventFactory;
+import org.bukkit.craftbukkit.util.CraftChatMessage;
+import org.bukkit.entity.Player;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.inventory.Inventory;
+
+public final class VersionWrapper {
+    public static final VersionWrapper INSTANCE = new VersionWrapper();
+
+    /**
+     * Interface implemented by the custom NMS AnvilContainer used to interact with it directly
+     */
+    public interface AnvilContainerWrapper {
+
+        /**
+         * Retrieves the raw text that has been entered into the Anvil at the moment
+         * <br><br>
+         * This field is marked as public in the Minecraft AnvilContainer only from Minecraft 1.11 and upwards
+         *
+         * @return The raw text in the rename field
+         */
+        default String getRenameText() {
+            return null;
+        }
+
+        /**
+         * Sets the provided text as the literal hovername of the item in the left input slot
+         *
+         * @param text The text to set
+         */
+        default void setRenameText(String text) {
+        }
+
+        /**
+         * Gets the {@link Inventory} wrapper of the NMS container
+         *
+         * @return The inventory of the NMS container
+         */
+        Inventory getBukkitInventory();
+    }
+
+    private static class AnvilContainer extends AnvilMenu implements AnvilContainerWrapper {
+        public AnvilContainer(Player player, int containerId, Component guiTitle) {
+            super(
+                    containerId,
+                    ((CraftPlayer) player).getHandle().getInventory(),
+                    ContainerLevelAccess.create(((CraftWorld) player.getWorld()).getHandle(), new BlockPos(0, 0, 0))
+            );
+            this.checkReachable = false;
+            setTitle(guiTitle);
+        }
+
+        public int getContainerId() {
+            return this.containerId;
+        }
+
+        public String getRenameText() {
+            return this.itemName;
+        }
+
+        public void setRenameText(String text) {
+            // If an item is present in the left input slot change its hover name to the literal text.
+            Slot inputLeft = getSlot(0);
+            if (inputLeft.hasItem()) {
+                inputLeft.getItem()
+                        .set(DataComponents.CUSTOM_NAME, Component.literal(text));
+            }
+        }
+
+        public Inventory getBukkitInventory() {
+            return this.getBukkitView().getTopInventory();
+        }
+    }
+
+    private int getRealNextContainerId(Player player) {
+        return toNMS(player).nextContainerCounter();
+    }
+
+    /**
+     * Turns a {@link Player} into an NMS one
+     *
+     * @param player The player to be converted
+     * @return the NMS EntityPlayer
+     */
+    private ServerPlayer toNMS(Player player) {
+        return ((CraftPlayer) player).getHandle();
+    }
+
+    public int getNextContainerId(Player player, AnvilContainerWrapper container) {
+        return ((AnvilContainer) container).getContainerId();
+    }
+
+    public void handleInventoryCloseEvent(Player player) {
+        CraftEventFactory.handleInventoryCloseEvent(toNMS(player), InventoryCloseEvent.Reason.UNKNOWN);
+        toNMS(player).doCloseContainer();
+    }
+
+    public void sendPacketOpenWindow(Player player, int containerId, Object inventoryTitle) {
+        toNMS(player).connection.send(new ClientboundOpenScreenPacket(containerId, MenuType.ANVIL, (Component) inventoryTitle));
+    }
+
+    public void sendPacketCloseWindow(Player player, int containerId) {
+        toNMS(player).connection.send(new ClientboundContainerClosePacket(containerId));
+    }
+
+    public void sendPacketExperienceChange(Player player, int experienceLevel) {
+        toNMS(player).connection.send(new ClientboundSetExperiencePacket(0f, 0, experienceLevel));
+    }
+
+    public void setActiveContainerDefault(Player player) {
+        toNMS(player).containerMenu = toNMS(player).inventoryMenu;
+    }
+
+    public void setActiveContainer(Player player, AnvilContainerWrapper container) {
+        toNMS(player).containerMenu = (AnvilMenu) container;
+    }
+
+    public void setActiveContainerId(AnvilContainerWrapper container, int containerId) {
+    }
+
+    public void addActiveContainerSlotListener(AnvilContainerWrapper container, Player player) {
+        toNMS(player).initMenu((AnvilMenu) container);
+    }
+
+    public AnvilContainerWrapper newContainerAnvil(Player player, Object title) {
+        return new AnvilContainer(player, getRealNextContainerId(player), (Component) title);
+    }
+
+    public Object literalChatComponent(String content) {
+        return Component.literal(content);
+    }
+
+    public Object jsonChatComponent(String json) {
+        return CraftChatMessage.fromJSON(json);
+    }
+}
Author	SHA1	Message	Date
D4rkr34lm	e07298e748	Move listener to permanent	2026-06-17 21:21:17 +02:00
D4rkr34lm	d7ba19049a	Add event handler	2026-06-17 21:10:55 +02:00
D4rkr34lm	47909b6f07	Add listener to prevent dried ghasts from growing	2026-06-17 21:09:07 +02:00
YoyoNow	669235709e	Fix WorldEditListener	2026-06-12 15:14:09 +02:00
YoyoNow	796e154c1c	Fix paper in inventory	2026-06-12 15:07:46 +02:00
YoyoNow	9efe35fe0d	Update LobbySystem run task	2026-06-12 14:52:46 +02:00
YoyoNow	e0aaacd66a	Fix AnvilGUI for 1.21 not being mojmapped	2026-06-12 14:52:03 +02:00
Chaoscaot	27877938bc	Add support for GameMode templates and YAML-based configuration handling in DevCommand. Signed-off-by: Chaoscaot <max@maxsp.de>	2026-06-12 12:29:56 +02:00