finished boat race

.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
-    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Minigames" />
+    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
   </state>
 </component>

.idea/compiler.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="CompilerConfiguration">
-    <bytecodeTargetLevel target="25" />
+    <bytecodeTargetLevel target="21" />
   </component>
 </project>

.idea/misc.xml

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <project version="4">
   <component name="ExternalStorageConfigurationManager" enabled="true" />
-  <component name="ProjectRootManager" version="2" languageLevel="JDK_25" default="true" project-jdk-name="openjdk-25" project-jdk-type="JavaSDK" />
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_21" default="true" project-jdk-name="21" project-jdk-type="JavaSDK" />
 </project>

.idea/modules.xml

@@ -4,6 +4,7 @@
     <modules>
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/Minigames.main.iml" filepath="$PROJECT_DIR$/.idea/modules/Minigames.main.iml" />
       <module fileurl="file://$PROJECT_DIR$/.idea/modules/Minigames.test.iml" filepath="$PROJECT_DIR$/.idea/modules/Minigames.test.iml" />
+      <module fileurl="file://$PROJECT_DIR$/.idea/modules/eu.mhsl.minenet.Minigames.main.iml" filepath="$PROJECT_DIR$/.idea/modules/eu.mhsl.minenet.Minigames.main.iml" />
     </modules>
   </component>
 </project>

.idea/modules/Minigames.main.iml

@@ -10,4 +10,8 @@
       </configuration>
     </facet>
   </component>
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
 </module>

build.gradle

@@ -3,7 +3,7 @@
 
 plugins {
     id 'java'
-    id "com.github.johnrengelman.shadow" version "8.1.1"
+    id "com.github.johnrengelman.shadow" version "7.1.0"
 }
 
 group 'eu.mhsl.minenet'
@@ -35,7 +35,7 @@ allprojects {
 
 java {
     toolchain {
-        languageVersion = JavaLanguageVersion.of(25)
+        languageVersion = JavaLanguageVersion.of(21)
     }
 }
 
@@ -44,7 +44,7 @@ dependencies {
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
 
     //https://jitpack.io/#Minestom/Minestom
-    implementation 'net.minestom:minestom:2025.10.11-1.21.10'
+    implementation 'net.minestom:minestom-snapshots:fd51c8d17a'
 
     //Tools
     implementation 'de.articdive:jnoise:3.0.2'
@@ -57,12 +57,12 @@ dependencies {
 
 
     //PvP
-    implementation 'io.github.TogAr2:MinestomPvP:56a831b41cb2ec6db8da681ad5d212ed7c71e3ee'
+    implementation 'io.github.TogAr2:MinestomPvP:PR62-SNAPSHOT'
 
     // Hephaestus engine
-    implementation("team.unnamed:hephaestus-api:0.2.1-SNAPSHOT")
+//    implementation("team.unnamed:hephaestus-api:0.2.1-SNAPSHOT")
-    implementation("team.unnamed:hephaestus-reader-blockbench:0.2.1-SNAPSHOT")
+//    implementation("team.unnamed:hephaestus-reader-blockbench:0.2.1-SNAPSHOT")
-    implementation("team.unnamed:hephaestus-runtime-minestom:0.2.1-SNAPSHOT")
+//    implementation("team.unnamed:hephaestus-runtime-minestom:0.2.1-SNAPSHOT")
 }
 
 tasks {

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-9.1.0-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-8.10-bin.zip
 networkTimeout=10000
 validateDistributionUrl=true
 zipStoreBase=GRADLE_USER_HOME

src/main/java/eu/mhsl/minenet/minigames/Main.java

@@ -3,13 +3,12 @@ package eu.mhsl.minenet.minigames;
 import eu.mhsl.minenet.minigames.api.HttpServer;
 import eu.mhsl.minenet.minigames.command.Commands;
 import eu.mhsl.minenet.minigames.handler.Listeners;
-import eu.mhsl.minenet.minigames.instance.Dimension;
 import eu.mhsl.minenet.minigames.lang.Languages;
 import eu.mhsl.minenet.minigames.server.tasks.TablistUpdateTask;
-import io.github.togar2.pvp.MinestomPvP;
-import net.minestom.server.Auth;
 import net.minestom.server.MinecraftServer;
+import net.minestom.server.extras.bungee.BungeeCordProxy;
 import net.minestom.server.extras.lan.OpenToLAN;
+import net.minestom.server.extras.velocity.VelocityProxy;
 import net.minestom.server.timer.TaskSchedule;
 import org.spongepowered.configurate.ConfigurateException;
 import org.spongepowered.configurate.ConfigurationNode;
@@ -26,7 +25,7 @@ public class Main {
     public static ConfigurationNode globalConfig;
 
     @SuppressWarnings("ResultOfMethodCallIgnored")
-    static void main() throws ConfigurateException {
+    public static void main(String[] args) throws ConfigurateException {
         //noinspection ResultOfMethodCallIgnored
         Resource.values(); // This initializes and preloads the enum and extracts the resources
         Languages.getInstance(); //Preload languages into the jvm
@@ -41,35 +40,29 @@ public class Main {
 
         logger.info("Initialize Minecraft server...");
 
-        MinecraftServer server = null;
+        MinecraftServer server = MinecraftServer.init();
-        if(serverConfig.node("open-to-lan").getBoolean()) OpenToLAN.open();
+//        MinestomPvP.init();
-
-        if(globalConfig.node("bungeecord", "enabled").getBoolean()) {
-            server = MinecraftServer.init(new Auth.Bungee());
-        }
-
-        if(globalConfig.node("velocity", "enabled").getBoolean()) {
-            server = MinecraftServer.init(new Auth.Velocity(Objects.requireNonNull(globalConfig.node("velocity", "secret").getString())));
-        }
-
-        if(server == null) server = MinecraftServer.init();
-
-        MinestomPvP.init();
 
         MinecraftServer.setBrandName("mhsl.eu - minenet - credits to minestom");
         MinecraftServer.setCompressionThreshold(serverConfig.node("compression-threshold").getInt(0));
         System.setProperty("minestom.chunk-view-distance", String.valueOf(serverConfig.node("view-distance").getInt()));
-        System.setProperty("minestom.registry.unsafe-ops", "true");
 
         Commands.values();
         Listeners.values();
-        Dimension.values();
         new HttpServer();
 
         MinecraftServer.getSchedulerManager().scheduleTask(new TablistUpdateTask(), TaskSchedule.tick(20), TaskSchedule.tick(20));
 
         logger.info("Starting Minecraft server ... ");
 
+        if(serverConfig.node("open-to-lan").getBoolean()) OpenToLAN.open();
+
+        if(globalConfig.node("bungeecord", "enabled").getBoolean()) BungeeCordProxy.enable();
+
+        if(globalConfig.node("velocity", "enabled").getBoolean()) {
+            VelocityProxy.enable(Objects.requireNonNull(globalConfig.node("velocity", "secret").getString()));
+        }
+
         server.start("0.0.0.0", serverConfig.node("port").getInt(25565));
         System.gc();
 

src/main/java/eu/mhsl/minenet/minigames/command/privileged/SetMemorialCommand.java

@@ -21,7 +21,7 @@ public class SetMemorialCommand extends PrivilegedCommand {
         ArgumentString loreArgument = ArgumentType.String("lore");
 
         materialArgument.setSuggestionCallback(
-            (_, _, suggestion) -> Material
+            (sender, context, suggestion) -> Material
                 .values()
                 .stream()
                 .map(material -> new SuggestionEntry(material.name(), Component.text(material.name())))
@@ -35,7 +35,7 @@ public class SetMemorialCommand extends PrivilegedCommand {
                 .getTournament()
                 .setMemorialConfiguration(
                     new MemorialConfiguration(
-                        Material.fromKey(context.get(materialArgument)),
+                        Material.fromNamespaceId(context.get(materialArgument)),
                         context.get(titleArgument),
                         context.get(loreArgument)
                     )

src/main/java/eu/mhsl/minenet/minigames/command/privileged/SetRewardCommand.java

@@ -23,7 +23,7 @@ public class SetRewardCommand extends PrivilegedCommand {
         ArgumentStringArray amountsArgument = ArgumentType.StringArray("amount");
 
         materialArgument.setSuggestionCallback(
-            (_, _, suggestion) -> Material
+            (sender, context, suggestion) -> Material
                 .values()
                 .stream()
                 .map(material -> new SuggestionEntry(material.name(), Component.text(material.name())))
@@ -37,7 +37,7 @@ public class SetRewardCommand extends PrivilegedCommand {
                 .getTournament()
                 .setRewardConfiguration(
                     new RewardConfiguration(
-                        Material.fromKey(context.get(materialArgument)),
+                        Material.fromNamespaceId(context.get(materialArgument)),
                         Arrays.stream(context.get(amountsArgument)).map(Integer::valueOf).collect(Collectors.toList())
                     )
                 );

src/main/java/eu/mhsl/minenet/minigames/command/privileged/SetRoomOwnerCommand.java

@@ -25,6 +25,7 @@ public class SetRoomOwnerCommand extends PrivilegedCommand {
         });
 
         this.addSyntax((sender, context) -> {
+            System.out.println("Test");
             if(sender instanceof Player p) {
                 Player newOwner = MinecraftServer.getConnectionManager().getOnlinePlayerByUsername(context.getRaw("player"));
                 Room.getRoom(p).orElseThrow().setOwner(Objects.requireNonNull(newOwner));

src/main/java/eu/mhsl/minenet/minigames/instance/Dimension.java

@@ -1,50 +1,49 @@
 package eu.mhsl.minenet.minigames.instance;
 
-import net.kyori.adventure.key.Key;
 import net.minestom.server.MinecraftServer;
-import net.minestom.server.registry.RegistryKey;
+import net.minestom.server.registry.DynamicRegistry;
+import net.minestom.server.utils.NamespaceID;
 import net.minestom.server.world.DimensionType;
-import org.jetbrains.annotations.NotNull;
 
 /**
  * Prebuilt dimensions
  */
 public enum Dimension {
     OVERWORLD(
-        Key.key("minenet:fullbright_overworld"),
+        NamespaceID.from("minenet:fullbright_overworld"),
         DimensionType
             .builder()
-            .ambientLight(1.0f)
+            .ambientLight(2.0f)
             .build()
     ),
 
     NETHER(
-        Key.key("minenet:fullbright_nether"),
+        NamespaceID.from("minenet:fullbright_nether"),
         DimensionType
             .builder()
-            .ambientLight(1.0f)
+            .ambientLight(2.0f)
             .effects("minecraft:the_nether")
             .build()
     ),
 
     THE_END(
-        Key.key("minenet:fullbright_end"),
+        NamespaceID.from("minenet:fullbright_end"),
         DimensionType
             .builder()
-            .ambientLight(1.0f)
+            .ambientLight(2.0f)
             .effects("minecraft:the_end")
             .build()
     );
 
     public final DimensionType DIMENSION;
-    public final Key namespaceID;
+    public final NamespaceID namespaceID;
-    public final RegistryKey<@NotNull DimensionType> key;
+    public final DynamicRegistry.Key<DimensionType> key;
 
-    Dimension(Key namespaceID, DimensionType dimType) {
+    Dimension(NamespaceID namespaceID, DimensionType dimType) {
         this.DIMENSION = dimType;
         this.namespaceID = namespaceID;
 
-        this.key = MinecraftServer.getDimensionTypeRegistry().register(this.namespaceID, this.DIMENSION);
+        this.key = MinecraftServer.getDimensionTypeRegistry().register(namespaceID, this.DIMENSION);
     }
 
 }

src/main/java/eu/mhsl/minenet/minigames/instance/MineNetInstance.java

@@ -7,15 +7,14 @@ import net.minestom.server.event.instance.AddEntityToInstanceEvent;
 import net.minestom.server.event.instance.RemoveEntityFromInstanceEvent;
 import net.minestom.server.instance.Instance;
 import net.minestom.server.instance.InstanceContainer;
-import net.minestom.server.registry.RegistryKey;
+import net.minestom.server.registry.DynamicRegistry;
 import net.minestom.server.timer.TaskSchedule;
 import net.minestom.server.world.DimensionType;
-import org.jetbrains.annotations.NotNull;
 
 import java.util.UUID;
 
 public class MineNetInstance extends InstanceContainer {
-    public MineNetInstance(RegistryKey<@NotNull DimensionType> type) {
+    public MineNetInstance(DynamicRegistry.Key<DimensionType> type) {
         super(UUID.randomUUID(), type);
         MinecraftServer.getInstanceManager().registerInstance(this);
 

src/main/java/eu/mhsl/minenet/minigames/instance/game/Game.java

@@ -16,7 +16,7 @@ import net.minestom.server.event.item.ItemDropEvent;
 import net.minestom.server.event.player.PlayerBlockBreakEvent;
 import net.minestom.server.event.player.PlayerBlockPlaceEvent;
 import net.minestom.server.event.player.PlayerMoveEvent;
-import net.minestom.server.registry.RegistryKey;
+import net.minestom.server.registry.DynamicRegistry;
 import net.minestom.server.timer.ExecutionType;
 import net.minestom.server.timer.TaskSchedule;
 import net.minestom.server.world.DimensionType;
@@ -34,7 +34,7 @@ public abstract class Game extends MineNetInstance implements Spawnable {
     protected boolean isRunning = false;
     protected boolean isBeforeBeginning = true;
 
-    public Game(RegistryKey<@NotNull DimensionType> dimensionType) {
+    public Game(DynamicRegistry.Key<DimensionType> dimensionType) {
         super(dimensionType);
 
         MinecraftServer.getInstanceManager().registerInstance(this);

src/main/java/eu/mhsl/minenet/minigames/instance/game/GameList.java

@@ -6,6 +6,7 @@ import eu.mhsl.minenet.minigames.instance.game.stateless.types.anvilRun.AnvilRun
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.backrooms.BackroomsFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.bedwars.BedwarsFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.blockBreakRace.BlockBreakRaceFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.boatRace.BoatRaceFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.bowSpleef.BowSpleefFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.deathcube.DeathcubeFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.elytraRace.ElytraRaceFactory;
@@ -44,7 +45,8 @@ public enum GameList {
     HIGHGROUND(new HighGroundFactory(), GameType.PVP),
     FASTBRIDGE(new FastbridgeFactory(), GameType.OTHER),
     BLOCKBREAKRACE(new BlockBreakRaceFactory(), GameType.OTHER),
-    SPACESNAKE(new SpaceSnakeFactory(), GameType.PVP);
+    SPACESNAKE(new SpaceSnakeFactory(), GameType.PVP),
+    BOATRACE(new BoatRaceFactory(), GameType.OTHER);
 
     private final GameFactory factory;
     private final GameType type;

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/StatelessGame.java

@@ -9,12 +9,11 @@ import eu.mhsl.minenet.minigames.score.Score;
 import net.kyori.adventure.audience.Audience;
 import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
-import net.minestom.server.registry.RegistryKey;
+import net.minestom.server.registry.DynamicRegistry;
 import net.minestom.server.timer.ExecutionType;
 import net.minestom.server.timer.Task;
 import net.minestom.server.timer.TaskSchedule;
 import net.minestom.server.world.DimensionType;
-import org.jetbrains.annotations.NotNull;
 
 import java.time.Duration;
 import java.util.concurrent.CompletableFuture;
@@ -27,7 +26,7 @@ public class StatelessGame extends Game {
     private int timeLimit = 0;
     private int timePlayed = 0;
 
-    public StatelessGame(RegistryKey<@NotNull DimensionType> dimensionType, String gameName, Score score) {
+    public StatelessGame(DynamicRegistry.Key<DimensionType> dimensionType, String gameName, Score score) {
         super(dimensionType);
         this.score = score;
         this.name = gameName;

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/config/GameConfigurationInventory.java

@@ -15,7 +15,8 @@ import net.minestom.server.entity.Player;
 import net.minestom.server.event.instance.AddEntityToInstanceEvent;
 import net.minestom.server.event.instance.RemoveEntityFromInstanceEvent;
 import net.minestom.server.inventory.InventoryType;
-import net.minestom.server.inventory.click.Click;
+import net.minestom.server.inventory.click.ClickType;
+import net.minestom.server.inventory.condition.InventoryConditionResult;
 import net.minestom.server.item.ItemStack;
 import net.minestom.server.item.Material;
 import net.minestom.server.sound.SoundEvent;
@@ -38,8 +39,8 @@ public class GameConfigurationInventory extends InteractableInventory {
         this.factory = factory;
 
         room.eventNode()
-            .addListener(AddEntityToInstanceEvent.class, _ -> MinecraftServer.getSchedulerManager().scheduleNextTick(this::updatePlayButton))
+            .addListener(AddEntityToInstanceEvent.class, addEntityToInstanceEvent -> MinecraftServer.getSchedulerManager().scheduleNextTick(this::updatePlayButton))
-            .addListener(RemoveEntityFromInstanceEvent.class, _ -> MinecraftServer.getSchedulerManager().scheduleNextTick(this::updatePlayButton));
+            .addListener(RemoveEntityFromInstanceEvent.class, removeEntityFromInstanceEvent -> MinecraftServer.getSchedulerManager().scheduleNextTick(this::updatePlayButton));
 
         ConfigManager config = factory.configuration();
 
@@ -52,7 +53,7 @@ public class GameConfigurationInventory extends InteractableInventory {
                 )
                 .build(),
             0,
-            itemClick -> itemClick.player().closeInventory(),
+            itemClick -> itemClick.getPlayer().closeInventory(),
             true
         );
 
@@ -105,7 +106,8 @@ public class GameConfigurationInventory extends InteractableInventory {
     }
 
     @Override
-    protected void onClick(Player player, int slot, Click clickType) {
+    protected void onClick(Player player, int slot, ClickType clickType, InventoryConditionResult inventoryConditionResult) {
+        inventoryConditionResult.setCancel(true);
 
         if(!this.map.containsKey(slot)) return;
 
@@ -131,7 +133,7 @@ public class GameConfigurationInventory extends InteractableInventory {
                     .lore(restrictionHandler.getWarnings(restrictionData).stream().map(translatedComponent -> translatedComponent.getAssembled(this.p)).collect(Collectors.toList()))
                     .build(),
                 8,
-                itemClick -> Game.initialize(this.factory, this.map.values().stream().toList(), itemClick.player()),
+                itemClick -> Game.initialize(this.factory, this.map.values().stream().toList(), itemClick.getPlayer()),
                 true
             );
 
@@ -153,7 +155,7 @@ public class GameConfigurationInventory extends InteractableInventory {
                         this.updatePlayButton();
                         return;
                     }
-                    itemClick.player().playSound(Sound.sound(SoundEvent.ENTITY_SILVERFISH_DEATH, Sound.Source.AMBIENT, 1f, 1f));
+                    itemClick.getPlayer().playSound(Sound.sound(SoundEvent.ENTITY_SILVERFISH_DEATH, Sound.Source.AMBIENT, 1f, 1f));
                 },
                 false
             );

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/boatRace/BoatRace.java

@@ -0,0 +1,75 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.boatRace;
+
+import eu.mhsl.minenet.minigames.Resource;
+import eu.mhsl.minenet.minigames.handler.global.PlayerLoginHandler;
+import eu.mhsl.minenet.minigames.instance.Dimension;
+import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
+import eu.mhsl.minenet.minigames.score.FirstWinsScore;
+import eu.mhsl.minenet.minigames.util.CommonProperties;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.entity.GameMode;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.player.PlayerMoveEvent;
+import net.minestom.server.instance.anvil.AnvilLoader;
+import net.minestom.server.instance.block.Block;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.concurrent.CompletableFuture;
+
+
+public class BoatRace extends StatelessGame {
+    public BoatRace() {
+        super(Dimension.OVERWORLD.key, "boatRace", new FirstWinsScore());
+        this.setChunkLoader(new AnvilLoader(Resource.GAME_MAP.getPath().resolve("boatRace/woodlandMansion")));
+    }
+
+    @Override
+    protected boolean onPlayerJoin(Player p) {
+        Entity boat = new Entity(EntityType.OAK_BOAT);
+        boat.setInstance(this, this.getSpawn());
+        boat.setSynchronizationTicks(100000);
+        PlayerLoginHandler.globalTeam.addMember(boat.getUuid().toString());
+        MinecraftServer.getSchedulerManager().scheduleNextTick(() -> boat.addPassenger(p));
+        return super.onPlayerJoin(p);
+    }
+
+    @Override
+    protected void onLoad(@NotNull CompletableFuture<Void> callback) {
+        for(int z = 9; z <= 32; z++) {
+            this.setBlock(31, 235, z, Block.CHERRY_FENCE.withProperties(CommonProperties.fenceNorthSouth));
+        }
+    }
+
+    @Override
+    protected void onStart() {
+        for(int z = 9; z <= 32; z++) {
+            this.setBlock(31, 235, z, Block.AIR);
+        }
+    }
+
+    @Override
+    protected void onPlayerMove(@NotNull PlayerMoveEvent event) {
+        if (this.isBeforeBeginning) return;
+
+        if(event.getNewPosition().z() > 469) {
+            Player player = event.getPlayer();
+            this.getScore().insertResult(player);
+
+            Entity vehicle = player.getVehicle();
+            if(vehicle != null) {
+                vehicle.removePassenger(player);
+                player.teleport(player.getPosition().withY(y -> y + 3));
+                player.setGameMode(GameMode.SPECTATOR);
+                vehicle.remove();
+            }
+        }
+    }
+
+    @Override
+    public Pos getSpawn() {
+        return new Pos(20, 236, 20, -90, 0);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/boatRace/BoatRaceFactory.java

@@ -0,0 +1,27 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.boatRace;
+
+import eu.mhsl.minenet.minigames.instance.game.Game;
+import eu.mhsl.minenet.minigames.instance.game.stateless.config.GameFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.config.Option;
+import eu.mhsl.minenet.minigames.instance.room.Room;
+import eu.mhsl.minenet.minigames.message.component.TranslatedComponent;
+import net.minestom.server.item.Material;
+
+import java.util.Map;
+
+public class BoatRaceFactory implements GameFactory {
+    @Override
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_BoatRace#name");
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.OAK_BOAT;
+    }
+
+    @Override
+    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
+        return new BoatRace().setParent(parent);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/deathcube/Deathcube.java

@@ -35,6 +35,7 @@ class Deathcube extends StatelessGame {
                 .add(CombatFeatures.VANILLA_KNOCKBACK)
                 .build().createNode()
         );
+        System.out.println(radius);
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/highGround/HighGround.java

@@ -8,7 +8,6 @@ import io.github.togar2.pvp.events.EntityKnockbackEvent;
 import io.github.togar2.pvp.events.FinalAttackEvent;
 import io.github.togar2.pvp.events.PrepareAttackEvent;
 import io.github.togar2.pvp.feature.CombatFeatures;
-import io.github.togar2.pvp.feature.knockback.KnockbackSettings;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.instance.InstanceTickEvent;
@@ -51,7 +50,7 @@ class HighGround extends StatelessGame {
 
         this.eventNode().addListener(
             EntityKnockbackEvent.class,
-            entityKnockbackEvent -> entityKnockbackEvent.setSettings(new KnockbackSettings(1.1, 1.1, 2, 0, 0))
+            entityKnockbackEvent -> entityKnockbackEvent.setStrength(1.1f)
         );
 
         this.eventNode().addListener(InstanceTickEvent.class, instanceTickEvent -> {

src/main/java/eu/mhsl/minenet/minigames/instance/hub/inventory/HubInventory.java

@@ -19,7 +19,7 @@ public class HubInventory extends InteractableInventory {
                 .lore(TranslatedComponent.assemble("hub#create_description", p))
                 .build(),
             12,
-            itemClick -> Room.createRoom(itemClick.player()),
+            itemClick -> Room.createRoom(itemClick.getPlayer()),
             true
         );
 
@@ -30,7 +30,7 @@ public class HubInventory extends InteractableInventory {
                 .lore(TranslatedComponent.assemble("hub#join_description", p))
                 .build(),
             14,
-            itemClick -> itemClick.player().openInventory(new JoinInventory(itemClick.player()))
+            itemClick -> itemClick.getPlayer().openInventory(new JoinInventory(itemClick.getPlayer()))
         );
     }
 }

src/main/java/eu/mhsl/minenet/minigames/instance/hub/inventory/JoinInventory.java

@@ -11,7 +11,8 @@ import net.minestom.server.MinecraftServer;
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.player.PlayerPacketEvent;
 import net.minestom.server.inventory.InventoryType;
-import net.minestom.server.inventory.click.Click;
+import net.minestom.server.inventory.click.ClickType;
+import net.minestom.server.inventory.condition.InventoryConditionResult;
 import net.minestom.server.item.ItemStack;
 import net.minestom.server.item.Material;
 import net.minestom.server.network.packet.client.play.ClientNameItemPacket;
@@ -31,7 +32,7 @@ public class JoinInventory extends InteractableInventory {
                 .customName(Component.text(this.prefix))
                 .build(),
             0,
-            _ -> {
+            itemClick -> {
             }
         );
 
@@ -44,8 +45,9 @@ public class JoinInventory extends InteractableInventory {
     }
 
     @Override
-    protected void onClick(Player player, int slot, Click clickType) {
+    protected void onClick(Player player, int slot, ClickType clickType, InventoryConditionResult inventoryConditionResult) {
         if(slot != 2) return;
+        inventoryConditionResult.setCancel(true);
         player.closeInventory();
 
         this.typedText = this.formatInput(this.typedText);

src/main/java/eu/mhsl/minenet/minigames/instance/room/inventory/MinigameSelectInventory.java

@@ -33,7 +33,7 @@ public class MinigameSelectInventory extends InteractableInventory {
                     .lore(type.getDescription().addWrap().getWrappedAssembled(p))
                     .build(),
                 itemAlignment.next().get(),
-                _ -> this.drawGames(type)
+                itemClick -> this.drawGames(type)
             );
         }
 
@@ -62,8 +62,7 @@ public class MinigameSelectInventory extends InteractableInventory {
                     .lore(gameFactory.description().addWrap().getWrappedAssembled(this.p))
                     .build(),
                 offset + itemAlignment.next().get(),
-                itemClick -> itemClick.player().openInventory(new GameConfigurationInventory(this.room, itemClick.player(), gameFactory)),
+                itemClick -> itemClick.getPlayer().openInventory(new GameConfigurationInventory(this.room, itemClick.getPlayer(), gameFactory))
-                true
             );
         }
     }

src/main/java/eu/mhsl/minenet/minigames/score/tournament/Tournament.java

@@ -24,8 +24,8 @@ public class Tournament {
                 for(Player player : players) {
                     int points = (game.getScores().size() - count) + this.boost(count, game.getScores().size());
 
-                    data.computeIfPresent(player, (_, existingPoints) -> existingPoints + points);
+                    data.computeIfPresent(player, (existingPlayer, existingPoints) -> existingPoints + points);
-                    data.computeIfAbsent(player, _ -> points);
+                    data.computeIfAbsent(player, newPlayer -> points);
                 }
             }
         });
@@ -44,11 +44,11 @@ public class Tournament {
         }
 
         return new Rewards(
-            this.memorialConfiguration.memorialMaterial().key().value(),
+            this.memorialConfiguration.memorialMaterial().namespace().value(),
             this.memorialConfiguration.memorialTitle(),
             this.memorialConfiguration.memorialLore(),
             this.getGameScores().keySet().stream().map(Player::getUuid).toList(),
-            this.rewardConfiguration.item().key().value(),
+            this.rewardConfiguration.item().namespace().value(),
             itemCount
         );
     }

src/main/java/eu/mhsl/minenet/minigames/shared/inventory/InteractableInventory.java

@@ -2,64 +2,38 @@ package eu.mhsl.minenet.minigames.shared.inventory;
 
 import net.kyori.adventure.text.Component;
 import net.minestom.server.entity.Player;
-import net.minestom.server.event.inventory.InventoryPreClickEvent;
 import net.minestom.server.inventory.Inventory;
 import net.minestom.server.inventory.InventoryType;
-import net.minestom.server.inventory.click.Click;
+import net.minestom.server.inventory.click.ClickType;
+import net.minestom.server.inventory.condition.InventoryConditionResult;
 import net.minestom.server.item.ItemStack;
 import net.minestom.server.item.Material;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
-import java.util.HashMap;
-import java.util.Map;
 import java.util.function.Consumer;
 
 public class InteractableInventory extends Inventory {
-    private final Map<Integer, ClickableItem> clickableItems = new HashMap<>();
-
-    public record ItemClick(Player player, InteractableInventory inventory, int clickedSlot, ItemStack item, Click clickType) { }
-    public record ClickableItem(ItemStack item, int slot, Consumer<ItemClick> callback, boolean closeAfterClick) { }
-
     /**
      * Defines an Inventory with direct callbacks for ItemSlots
      */
     protected InteractableInventory(@NotNull InventoryType inventoryType, @NotNull Component title) {
         super(inventoryType, title);
 
-        this.eventNode().addListener(
+        this.addInventoryCondition(this::onClick);
-            InventoryPreClickEvent.class,
-            inventoryPreClickEvent -> this.onClick(
-                inventoryPreClickEvent.getPlayer(),
-                inventoryPreClickEvent.getSlot(),
-                inventoryPreClickEvent.getClick()
-            )
-        );
-
-        this.eventNode().addListener(InventoryPreClickEvent.class, inventoryPreClickEvent -> {
-            @Nullable ClickableItem selectedItem = this.clickableItems.values().stream()
-                .filter(clickableItem -> clickableItem.slot() == inventoryPreClickEvent.getSlot())
-                .findFirst()
-                .orElse(null);
-            if(selectedItem == null) {
-                inventoryPreClickEvent.setCancelled(true);
-                return;
-            }
-            if(selectedItem.closeAfterClick()) inventoryPreClickEvent.getPlayer().closeInventory();
-            selectedItem.callback().accept(
-                new ItemClick(inventoryPreClickEvent.getPlayer(), this, inventoryPreClickEvent.getSlot(), selectedItem.item(), inventoryPreClickEvent.getClick())
-            );
-            inventoryPreClickEvent.setCancelled(true);
-        });
     }
 
     /**
      * Set Item with Callback
      */
     protected void setClickableItem(ItemStack item, int slot, Consumer<ItemClick> callback, boolean closeAfter) {
-        ClickableItem clickableItem = new ClickableItem(item, slot, callback, closeAfter);
+        this.setItemStack(slot, item);
-        this.setItemStack(clickableItem.slot(), clickableItem.item());
+        this.addInventoryCondition((player, clickedSlot, clickType, inventoryConditionResult) -> {
-        this.clickableItems.put(clickableItem.slot(), clickableItem);
+            if(clickedSlot == slot) {
+                if(closeAfter) player.closeInventory();
+                callback.accept(new ItemClick(player, this, clickedSlot, item, clickType));
+            }
+            inventoryConditionResult.setCancel(true);
+        });
     }
 
     protected void setClickableItem(ItemStack item, int slot, Consumer<ItemClick> callback) {
@@ -73,7 +47,7 @@ public class InteractableInventory extends Inventory {
         this.setClickableItem(
             item,
             slot,
-            _ -> {
+            itemClick -> {
             }
         );
     }
@@ -88,7 +62,7 @@ public class InteractableInventory extends Inventory {
     /**
      * You may want to Override this method to get more generic click events
      */
-    protected void onClick(Player player, int slot, Click clickType) {
+    protected void onClick(Player player, int slot, ClickType clickType, InventoryConditionResult inventoryConditionResult) {
 
     }
 }

src/main/java/eu/mhsl/minenet/minigames/shared/inventory/ItemClick.java

@@ -0,0 +1,45 @@
+package eu.mhsl.minenet.minigames.shared.inventory;
+
+import net.minestom.server.entity.Player;
+import net.minestom.server.inventory.Inventory;
+import net.minestom.server.inventory.click.ClickType;
+import net.minestom.server.item.ItemStack;
+
+public class ItemClick {
+    private final Player player;
+    private final InteractableInventory inventory;
+    private final int clickedSlot;
+    private final ItemStack item;
+    private final ClickType clickType;
+
+    /**
+     * Describes a click on an Item from an IntractableInventory
+     */
+    public ItemClick(Player player, InteractableInventory inventory, int clickedSlot, ItemStack item, ClickType clickType) {
+        this.player = player;
+        this.inventory = inventory;
+        this.clickedSlot = clickedSlot;
+        this.item = item;
+        this.clickType = clickType;
+    }
+
+    public Player getPlayer() {
+        return this.player;
+    }
+
+    public Inventory getInventory() {
+        return this.inventory;
+    }
+
+    public int getClickedSlot() {
+        return this.clickedSlot;
+    }
+
+    public ItemStack getItem() {
+        return this.item;
+    }
+
+    public ClickType getClickType() {
+        return this.clickType;
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/util/BatchUtil.java

@@ -1,12 +1,12 @@
 package eu.mhsl.minenet.minigames.util;
 
+import it.unimi.dsi.fastutil.longs.Long2ObjectMap;
 import net.minestom.server.instance.InstanceContainer;
 import net.minestom.server.instance.batch.Batch;
 import net.minestom.server.instance.batch.ChunkBatch;
 import net.minestom.server.utils.chunk.ChunkUtils;
 
 import java.lang.reflect.Field;
-import java.util.Map;
 import java.util.concurrent.CompletableFuture;
 
 public class BatchUtil {
@@ -16,12 +16,9 @@ public class BatchUtil {
             field.setAccessible(true);
 
             @SuppressWarnings("unchecked")
-            Map<Long, ChunkBatch> chunkBatchesMap = (Map<Long, ChunkBatch>) field.get(batch);
+            Long2ObjectMap<ChunkBatch> chunkBatchesMap = (Long2ObjectMap<ChunkBatch>) field.get(batch);
 
-            long[] out = new long[chunkBatchesMap.size()];
+            return chunkBatchesMap.keySet().toLongArray();
-            int i = 0;
-            for (Long k : chunkBatchesMap.keySet()) out[i++] = k;
-            return out;
         } catch(NoSuchFieldException | IllegalAccessException e) {
             throw new RuntimeException(e);
         }
@@ -39,9 +36,15 @@ public class BatchUtil {
         long[] affectedChunks = BatchUtil.getAffectedChunks(batch);
         CompletableFuture<Void> loadChunksTask = ChunkUtils.optionalLoadAll(instance, affectedChunks, null);
 
-        Runnable completerTask = () -> future.complete(null);
+        Runnable completerTask = () -> {
+            System.out.println("COMPLETE");
+            future.complete(null);
+        };
 
-        loadChunksTask.thenRun(() -> batch.apply(instance, completerTask));
+        loadChunksTask.thenRun(() -> {
+            System.out.println("BEGIN");
+            batch.apply(instance, completerTask);
+        });
 
         try {
             future.get();

src/main/java/eu/mhsl/minenet/minigames/util/CommonProperties.java

@@ -10,4 +10,11 @@ public class CommonProperties {
             this.put("east", "true");
         }
     };
+
+    public static Map<String, String> fenceNorthSouth = new HashMap<>() {
+        {
+            this.put("north", "true");
+            this.put("south", "true");
+        }
+    };
 }

src/main/java/eu/mhsl/minenet/minigames/util/WeatherUtils.java

@@ -19,6 +19,7 @@ public class WeatherUtils {
         MinecraftServer.getSchedulerManager().submitTask(() -> {
             this.intensity += 0.1f;
             players.forEach(p -> p.sendPacket(new ChangeGameStatePacket(ChangeGameStatePacket.Reason.RAIN_LEVEL_CHANGE, this.intensity)));
+            System.out.println(this.intensity);
             if(this.intensity < 1) {
                 return TaskSchedule.millis(500);
             } else {

src/main/java/eu/mhsl/minenet/minigames/world/generator/featureEnriched/CircularPlateGenerator.java

@@ -38,6 +38,8 @@ public class CircularPlateGenerator extends HeightTerrainGenerator {
     @Override
     public void generate(@NotNull GenerationUnit unit) {
         this.execution.singleRun(() -> unit.fork(setter -> {
+            System.out.println(new Pos(-(this.radius + this.centerX), unit.absoluteStart().y(), -(this.radius + this.centerZ)));
+            System.out.println(new Pos(this.radius + this.centerX, this.height, this.radius + this.centerZ));
             GeneratorUtils.foreachXZ(
                 new Pos(-(this.radius + this.centerX), unit.absoluteStart().y(), -(this.radius + this.centerZ)),
                 new Pos(this.radius + this.centerX, this.height, this.radius + this.centerZ),

src/main/java/eu/mhsl/minenet/minigames/world/generator/terrain/HeightTerrainGenerator.java

@@ -46,6 +46,7 @@ public class HeightTerrainGenerator extends BaseGenerator {
                 double heightNoise = this.base.getNoise(bottomPoint.x(), bottomPoint.z());
                 double noiseModifier = heightNoise * this.heightNoiseMultiplier.apply(bottomPoint);
                 double heightModifier = NumberUtil.clamp(this.calculateHeight.apply(bottomPoint) + noiseModifier, 1d, unit.size().y());
+                if(heightModifier < 1) System.out.println("HEIGHT MODIFIER ILLEGAL");
 
                 synchronized(this.batches) {
                     double batchNoise = this.batches.getNoise(bottomPoint.x(), bottomPoint.z());
@@ -68,6 +69,8 @@ public class HeightTerrainGenerator extends BaseGenerator {
                         Point absoluteHeight = bottomPoint.add(0, heightModifier, 0);
                         int seaLevel = this.calculateSeaLevel.apply(bottomPoint);
                         if(absoluteHeight.y() < seaLevel) {
+//                            System.out.println("HM:" + absoluteHeight.y() + " SL:" + seaLevel);
+//                            System.out.println("Filling from " + bottomPoint.y() + " to " + absoluteHeight.withY(seaLevel).y());
                             unit.modifier().fill(bottomPoint.withY(v -> v + heightModifier), absoluteHeight.add(1, 0, 1).withY(seaLevel), Block.WATER);
                         }
                     }