reset player level

build.gradle

@@ -10,8 +10,6 @@ group 'eu.mhsl.minenet'
 version '1.0-SNAPSHOT'
 
 repositories {
-    //maven 'https://repo.unnamed.team/repository/unnamed-public/'
-
     mavenCentral()
     google()
 
@@ -46,7 +44,7 @@ dependencies {
     testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.9.0'
 
     //https://jitpack.io/#Minestom/Minestom
-    implementation 'net.minestom:minestom-snapshots:d707b0674f'
+    implementation 'net.minestom:minestom-snapshots:fd51c8d17a'
 
     //Tools
     implementation 'de.articdive:jnoise:3.0.2'
@@ -55,11 +53,11 @@ dependencies {
     implementation 'org.spongepowered:configurate-yaml:4.1.2'
     implementation 'com.sparkjava:spark-core:2.9.4'
     implementation 'com.google.code.gson:gson:2.10.1'
-    implementation 'com.google.guava:guava:32.0.0-android'
+    implementation 'com.google.guava:guava:32.0.1-android'
 
 
     //PvP
-    implementation 'com.github.TogAr2:MinestomPvP:04180ddf9a'
+    implementation 'io.github.TogAr2:MinestomPvP:PR62-SNAPSHOT'
 
     // Hephaestus engine
     implementation("team.unnamed:hephaestus-api:0.2.1-SNAPSHOT")

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -15,6 +15,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+# SPDX-License-Identifier: Apache-2.0
+#
 
 ##############################################################################
 #
@@ -25,7 +27,7 @@
 #   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
 #       noncompliant, but you have some other compliant shell such as ksh or
 #       bash, then to run this script, type that shell name before the whole
-#       eu.mhsl.minenet.minigames.command line, like:
+#       command line, like:
 #
 #           ksh Gradle
 #
@@ -35,7 +37,7 @@
 #         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
 #           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
 #         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «eu.mhsl.minenet.minigames.command», «set», and «ulimit».
+#         * various built-in commands including «command», «set», and «ulimit».
 #
 #   Important for patching:
 #
@@ -55,7 +57,7 @@
 #       Darwin, MinGW, and NonStop.
 #
 #   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       https://github.com/gradle/gradle/blob/HEAD/platforms/jvm/plugins-application/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
 #       within the Gradle project.
 #
 #       You can find Gradle at https://github.com/gradle/gradle/.
@@ -80,13 +82,12 @@ do
     esac
 done
 
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-APP_NAME="Gradle"
+# This is normally unused
+# shellcheck disable=SC2034
 APP_BASE_NAME=${0##*/}
-
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+# Discard cd standard output in case $CDPATH is set (https://github.com/gradle/gradle/issues/25036)
+APP_HOME=$( cd -P "${APP_HOME:-./}" > /dev/null && printf '%s
+' "$PWD" ) || exit
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD=maximum
@@ -117,7 +118,7 @@ esac
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 
-# Determine the Java eu.mhsl.minenet.minigames.command to use to start the JVM.
+# Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
@@ -133,29 +134,36 @@ location of your Java installation."
     fi
 else
     JAVACMD=java
-    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+    if ! command -v java >/dev/null 2>&1
+    then
+        die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
+    fi
 fi
 
 # Increase the maximum file descriptors if we can.
 if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
     case $MAX_FD in #(
       max*)
+        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         MAX_FD=$( ulimit -H -n ) ||
             warn "Could not query maximum file descriptor limit"
     esac
     case $MAX_FD in  #(
       '' | soft) :;; #(
       *)
+        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
+        # shellcheck disable=SC2039,SC3045
         ulimit -n "$MAX_FD" ||
             warn "Could not set maximum file descriptor limit to $MAX_FD"
     esac
 fi
 
-# Collect all arguments for the java eu.mhsl.minenet.minigames.command, stacking in reverse order:
-#   * args from the eu.mhsl.minenet.minigames.command line
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
 #   * the main class name
 #   * -classpath
 #   * -D...appname settings
@@ -193,11 +201,15 @@ if "$cygwin" || "$msys" ; then
     done
 fi
 
-# Collect all arguments for the java eu.mhsl.minenet.minigames.command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Collect all arguments for the java command:
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, JAVA_OPTS, and optsEnvironmentVar are not allowed to contain shell fragments,
+#     and any embedded shellness will be escaped.
+#   * For example: A user cannot expect ${Hostname} to be expanded, as it is an environment variable and will be
+#     treated as '${Hostname}' itself on the command line.
 
 set -- \
         "-Dorg.gradle.appname=$APP_BASE_NAME" \
@@ -205,6 +217,12 @@ set -- \
         org.gradle.wrapper.GradleWrapperMain \
         "$@"
 
+# Stop when "xargs" is not available.
+if ! command -v xargs >/dev/null 2>&1
+then
+    die "xargs is not available"
+fi
+
 # Use "xargs" to parse quoted args.
 #
 # With -n1 it outputs one arg per line, with the quotes and backslashes removed.
@@ -214,7 +232,7 @@ set -- \
 #   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
 #   set -- "${ARGS[@]}" "$@"
 #
-# but POSIX shell has neither arrays nor eu.mhsl.minenet.minigames.command substitution, so instead we
+# but POSIX shell has neither arrays nor command substitution, so instead we
 # post-process each arg (as a line of input to sed) to backslash-escape any
 # character that might be a shell metacharacter, then use eval to reverse
 # that process (while maintaining the separation between arguments), and wrap

gradlew.bat

@@ -13,8 +13,10 @@
 @rem See the License for the specific language governing permissions and
 @rem limitations under the License.
 @rem
+@rem SPDX-License-Identifier: Apache-2.0
+@rem
 
-@if "%DEBUG%" == "" @echo off
+@if "%DEBUG%"=="" @echo off
 @rem ##########################################################################
 @rem
 @rem  Gradle startup script for Windows
@@ -25,7 +27,8 @@
 if "%OS%"=="Windows_NT" setlocal
 
 set DIRNAME=%~dp0
-if "%DIRNAME%" == "" set DIRNAME=.
+if "%DIRNAME%"=="" set DIRNAME=.
+@rem This is normally unused
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
@@ -40,13 +43,13 @@ if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if %ERRORLEVEL% equ 0 goto execute
 
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' eu.mhsl.minenet.gameList.command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
@@ -56,16 +59,16 @@ set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
 if exist "%JAVA_EXE%" goto execute
 
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
+echo. 1>&2
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% 1>&2
+echo. 1>&2
+echo Please set the JAVA_HOME variable in your environment to match the 1>&2
+echo location of your Java installation. 1>&2
 
 goto fail
 
 :execute
-@rem Setup the eu.mhsl.minenet.gameList.command line
+@rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
@@ -75,13 +78,15 @@ set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
 :end
 @rem End local scope for the variables with windows NT shell
-if "%ERRORLEVEL%"=="0" goto mainEnd
+if %ERRORLEVEL% equ 0 goto mainEnd
 
 :fail
 rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
 rem the _cmd.exe /c_ return code!
-if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
-exit /b 1
+set EXIT_CODE=%ERRORLEVEL%
+if %EXIT_CODE% equ 0 set EXIT_CODE=1
+if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
+exit /b %EXIT_CODE%
 
 :mainEnd
 if "%OS%"=="Windows_NT" endlocal

src/main/java/eu/mhsl/minenet/minigames/command/Commands.java

@@ -1,6 +1,6 @@
 package eu.mhsl.minenet.minigames.command;
 
-import eu.mhsl.minenet.minigames.command.anonymous.SkinCommand;
+import eu.mhsl.minenet.minigames.command.privileged.SkinCommand;
 import eu.mhsl.minenet.minigames.command.privileged.*;
 import eu.mhsl.minenet.minigames.command.anonymous.HubCommand;
 import eu.mhsl.minenet.minigames.command.anonymous.LeaveCommand;
@@ -41,7 +41,7 @@ public enum Commands {
     static {
         MinecraftServer.getCommandManager().setUnknownCommandCallback((sender, command) -> {
             if(command.isBlank()) return;
-            new ChatMessage(Icon.ERROR).appendStatic("Unknown command").quote(command).send(sender);
+            new ChatMessage(Icon.ERROR).appendStatic("Unknown command: ").quote(command).send(sender);
         });
     }
 }

src/main/java/eu/mhsl/minenet/minigames/command/anonymous/HubCommand.java

@@ -10,9 +10,13 @@ public class HubCommand extends Command {
     public HubCommand() {
         super("hub");
 
-        setCondition((sender, commandString) -> ((Player) sender).getInstance() instanceof Room);
+        setCondition(
+            (sender, commandString) ->
+                ((Player) sender).getInstance() instanceof Room room && !room.apiDriven
+        );
 
         setDefaultExecutor((sender, context) -> {
+            if(Room.getRoom((Player) sender).orElseThrow().apiDriven) return;
             Room.unsetRoom((Player) sender);
             MoveInstance.move((Player) sender, Hub.INSTANCE);
         });

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

@@ -1,11 +1,11 @@
-package eu.mhsl.minenet.minigames.command.anonymous;
+package eu.mhsl.minenet.minigames.command.privileged;
 
-import net.minestom.server.command.builder.Command;
+import eu.mhsl.minenet.minigames.command.PrivilegedCommand;
 import net.minestom.server.command.builder.arguments.ArgumentType;
 import net.minestom.server.entity.Player;
 import net.minestom.server.entity.PlayerSkin;
 
-public class SkinCommand extends Command {
+public class SkinCommand extends PrivilegedCommand {
     public SkinCommand() {
         super("skin");
 

src/main/java/eu/mhsl/minenet/minigames/handler/global/PlayerLoginHandler.java

@@ -11,6 +11,8 @@ import net.minestom.server.entity.Player;
 import eu.mhsl.minenet.minigames.instance.hub.Hub;
 import net.minestom.server.event.EventListener;
 import net.minestom.server.event.player.AsyncPlayerConfigurationEvent;
+import net.minestom.server.network.packet.server.play.TeamsPacket;
+import net.minestom.server.scoreboard.Team;
 import net.minestom.server.timer.TaskSchedule;
 import org.jetbrains.annotations.NotNull;
 import org.spongepowered.configurate.serialize.SerializationException;
@@ -20,6 +22,11 @@ import java.util.UUID;
 import java.util.logging.Logger;
 
 public class PlayerLoginHandler implements EventListener<AsyncPlayerConfigurationEvent> {
+    public static final Team globalTeam = MinecraftServer.getTeamManager()
+        .createBuilder("global")
+        .collisionRule(TeamsPacket.CollisionRule.NEVER)
+        .build();
+
     @Override
     public @NotNull Class<AsyncPlayerConfigurationEvent> eventType() {
         return AsyncPlayerConfigurationEvent.class;
@@ -37,13 +44,14 @@ public class PlayerLoginHandler implements EventListener<AsyncPlayerConfiguratio
 
         MinecraftServer.getSchedulerManager().scheduleTask(
             () -> {
+                p.setTeam(globalTeam);
                 if(pushQueue != null) {
                     Room.setRoom(p, Room.getRoom(pushQueue).orElseThrow());
                 } else {
                     MoveInstance.move(p, Hub.INSTANCE);
                 }
             },
-            TaskSchedule.seconds(5),
+            TaskSchedule.seconds(1),
             TaskSchedule.stop()
         );
 

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

@@ -11,7 +11,6 @@ import eu.mhsl.minenet.minigames.instance.Spawnable;
 import eu.mhsl.minenet.minigames.instance.room.Room;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.coordinate.Pos;
-import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.item.ItemDropEvent;
 import net.minestom.server.event.player.PlayerBlockBreakEvent;
@@ -43,13 +42,13 @@ public abstract class Game extends MineNetInstance implements Spawnable {
 
         MinecraftServer.getInstanceManager().registerInstance(this);
 
-        logger = Logger.getLogger("Game:" + getUniqueId());
+        logger = Logger.getLogger("Game:" + getUuid());
 
         eventNode()
-                .addListener(PlayerMoveEvent.class, this::onPlayerMove)
-                .addListener(PlayerBlockBreakEvent.class, this::onBlockBreak)
-                .addListener(PlayerBlockPlaceEvent.class, this::onBlockPlace)
-                .addListener(ItemDropEvent.class, this::onItemDrop);
+            .addListener(PlayerMoveEvent.class, this::onPlayerMove)
+            .addListener(PlayerBlockBreakEvent.class, this::onBlockBreak)
+            .addListener(PlayerBlockPlaceEvent.class, this::onBlockPlace)
+            .addListener(ItemDropEvent.class, this::onItemDrop);
     }
 
     public Game setParent(Room parentRoom) {
@@ -64,6 +63,17 @@ public abstract class Game extends MineNetInstance implements Spawnable {
             game.load();
             Room.getRoom(owner).orElseThrow().moveMembersToInstance(game);
 
+            MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+                game.getPlayers().forEach(player -> new ChatMessage(Icon.SCIENCE)
+                    .appendStatic(factory.name().getAssembled(player).asComponent())
+                    .newLine()
+                    .appendStatic(factory.description().getAssembled(player).asComponent())
+                    .send(player));
+
+                return TaskSchedule.stop();
+            }, TaskSchedule.seconds(3));
+
+
         } catch (Exception e) {
             new ChatMessage(Icon.ERROR).appendStatic("Instance crashed: " + e.getMessage()).send(owner);
             MinecraftServer.getSchedulerManager().scheduleNextTick(() -> Room.getRoom(owner).orElseThrow().moveMembersToRoomLobby());
@@ -99,15 +109,11 @@ public abstract class Game extends MineNetInstance implements Spawnable {
     public void unload() {
         this.onUnload();
 
-        getPlayers().forEach(player -> {
-            Room.setOwnRoom(player);
-            player.setGameMode(GameMode.SURVIVAL);
-            player.setInvisible(false);
-        });
+        getPlayers().forEach(Room::setOwnRoom);
 
         scheduler().scheduleTask(() -> {
 
-            logger.info("stopping game instance " + this.uniqueId);
+            logger.info("stopping game instance " + this.uuid);
             getPlayers().forEach(player -> player.kick("timeout"));
 
             MinecraftServer.getInstanceManager().unregisterInstance(this);

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

@@ -8,6 +8,7 @@ import eu.mhsl.minenet.minigames.instance.game.stateless.types.backrooms.Backroo
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.bedwars.BedwarsFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.acidRain.AcidRainFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.deathcube.DeathcubeFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.jumpDive.JumpDiveFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.minerun.MinerunFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.spleef.SpleefFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.stickfight.StickFightFactory;
@@ -18,19 +19,20 @@ import eu.mhsl.minenet.minigames.instance.game.stateless.types.trafficlightrace.
 
 public enum GameList {
     DEATHCUBE(new DeathcubeFactory(), GameType.JUMPNRUN),
-    STICKFIGHT(new StickFightFactory(), GameType.PVP),
     MINERUN(new MinerunFactory(), GameType.JUMPNRUN),
     TRAFFICLIGHTRACE(new TrafficLightRaceFactory(), GameType.OTHER),
+    STICKFIGHT(new StickFightFactory(), GameType.PROTOTYPE),
     TOWERDEFENSE(new TowerdefenseFactory(), GameType.PROTOTYPE),
     BEDWARS(new BedwarsFactory(), GameType.PROTOTYPE),
     BACKROOMS(new BackroomsFactory(), GameType.PROTOTYPE),
-    ANVILRUN(new AnvilRunFactory(), GameType.PROTOTYPE),
+    BOWSPLEEF(new BowSpleefFactory(), GameType.PROTOTYPE),
     TETRIS(new TetrisFactory(), GameType.OTHER),
     TNTRUN(new TntRunFactory(), GameType.OTHER),
+    ANVILRUN(new AnvilRunFactory(), GameType.PVE),
     ACIDRAIN(new AcidRainFactory(), GameType.PVE),
     ELYTRARACE(new ElytraRaceFactory(), GameType.PVP),
     SPLEEF(new SpleefFactory(), GameType.PVP),
-    BOWSPLEEF(new BowSpleefFactory(), GameType.PVP);
+    JUMPDIVE(new JumpDiveFactory(), GameType.JUMPNRUN);
 
     private final GameFactory factory;
     private final GameType type;

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

@@ -11,6 +11,7 @@ import net.kyori.adventure.text.Component;
 import net.kyori.adventure.text.format.NamedTextColor;
 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;
 
@@ -20,6 +21,7 @@ import java.util.concurrent.CompletableFuture;
 public class StatelessGame extends Game {
     private final String name;
     private final Score score;
+    private Task timeLimitTask;
 
     private int timeLimit = 0;
     private int timePlayed = 0;
@@ -40,8 +42,12 @@ public class StatelessGame extends Game {
 
     public void setTimeLimit(int limit) {
         this.timeLimit = limit;
-        if(timeLimit > 0) {
-            scheduler().submitTask(() -> {
+        if(this.timeLimitTask != null) {
+            this.timeLimitTask.cancel();
+            this.timePlayed = 0;
+        }
+        if(this.timeLimit > 0) {
+            this.timeLimitTask = scheduler().submitTask(() -> {
                 if(!isRunning || timeLimit == 0) return TaskSchedule.stop();
                 if(timeLimit <= timePlayed) {
                     stop();

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/acidRain/AcidRainFactory.java

@@ -15,6 +15,11 @@ public class AcidRainFactory implements GameFactory {
         return TranslatedComponent.byId("game_AcidRain#name");
     }
 
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_AcidRain#description");
+    }
+
     @Override
     public Material symbol() {
         return Material.SLIME_BALL;

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/bowSpleef/BowSpleefFactory.java

@@ -12,7 +12,12 @@ import java.util.Map;
 public class BowSpleefFactory implements GameFactory {
     @Override
     public TranslatedComponent name() {
-        return TranslatedComponent.byId("");
+        return TranslatedComponent.byId("game_BowSpleef#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_BowSpleef#description");
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/elytraRace/ElytraRace.java

@@ -169,6 +169,7 @@ public class ElytraRace extends StatelessGame {
         if(newPos.z() > ringCount * ringSpacing) {
             getScore().insertResult(player);
             player.setGameMode(GameMode.SPECTATOR);
+            player.setFlyingWithElytra(false);
         }
     }
 

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/elytraRace/ElytraRaceFactory.java

@@ -14,7 +14,12 @@ import java.util.Map;
 public class ElytraRaceFactory implements GameFactory {
     @Override
     public TranslatedComponent name() {
-        return TranslatedComponent.byId("");
+        return TranslatedComponent.byId("game_ElytraRace#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_ElytraRace#description");
     }
 
     @Override
@@ -25,7 +30,7 @@ public class ElytraRaceFactory implements GameFactory {
     @Override
     public ConfigManager configuration() {
         return new ConfigManager()
-                .addOption(new NumericOption("ringCount", Material.DIAMOND_BLOCK, TranslatedComponent.byId("ringCount"), 5, 10, 20, 30, 40, 50));
+                .addOption(new NumericOption("ringCount", Material.DIAMOND_BLOCK, TranslatedComponent.byId("game_ElytraRace#ringCount"), 5, 10, 20, 30, 40, 50));
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/jumpDive/JumpDive.java

@@ -0,0 +1,99 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.jumpDive;
+
+import eu.mhsl.minenet.minigames.instance.Dimension;
+import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
+import eu.mhsl.minenet.minigames.score.PointsWinScore;
+import eu.mhsl.minenet.minigames.util.BatchUtil;
+import eu.mhsl.minenet.minigames.world.BlockPallet;
+import net.kyori.adventure.sound.Sound;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.player.PlayerMoveEvent;
+import net.minestom.server.instance.batch.AbsoluteBlockBatch;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.sound.SoundEvent;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.WeakHashMap;
+import java.util.concurrent.CompletableFuture;
+
+public class JumpDive extends StatelessGame {
+    private final int radius;
+    private final int height;
+    private final int timeLimit;
+
+    private final WeakHashMap<Player, Integer> scores = new WeakHashMap<>();
+
+    public JumpDive(int radius, int height, int timeLimit) {
+        super(Dimension.OVERWORLD.key, "jumpDive", new PointsWinScore());
+        this.radius = radius;
+        this.height = height;
+        this.timeLimit = timeLimit;
+    }
+
+    @Override
+    protected void onLoad(@NotNull CompletableFuture<Void> callback) {
+        AbsoluteBlockBatch batch = new AbsoluteBlockBatch();
+
+        for(int x = -radius*2; x <= radius*2; x++) {
+            for(int z = -radius*2; z <= radius*2; z++) {
+                if(new Pos(x, 0, z).distance(new Pos(0, 0, 0)) > radius) {
+                    batch.setBlock(x, height, z, BlockPallet.STONE.rnd());
+                } else {
+                    batch.setBlock(x, 0, z, BlockPallet.GROUND.rnd());
+                    batch.setBlock(x, 1, z, Block.WATER);
+                }
+            }
+        }
+
+        BatchUtil.loadAndApplyBatch(batch, this, () -> callback.complete(null));
+    }
+
+    @Override
+    protected void onStart() {
+        setTimeLimit(timeLimit);
+    }
+
+    @Override
+    protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
+        Player p = playerMoveEvent.getPlayer();
+
+        if(
+            p.isOnGround() && playerMoveEvent.getNewPosition().y() < height
+            || playerMoveEvent.getNewPosition().y() < 0
+            || isBeforeBeginning && playerMoveEvent.getNewPosition().y() < height
+        ) {
+            p.teleport(getSpawn());
+            playerMoveEvent.setCancelled(true);
+        }
+
+        if(
+            playerMoveEvent.getNewPosition().y() <= 1
+            && playerMoveEvent.getNewPosition().distance(0, 1, 0) < radius + 0.5
+            && !(!isBeforeBeginning && !isRunning)
+        ) {
+            setBlock(playerMoveEvent.getNewPosition().withY(1), Block.REDSTONE_BLOCK);
+            scores.merge(p, 1, Integer::sum);
+            p.teleport(getSpawn());
+            playerMoveEvent.setCancelled(true);
+            p.playSound(Sound.sound(SoundEvent.ENTITY_EXPERIENCE_ORB_PICKUP, Sound.Source.PLAYER, 2f, 2f));
+        }
+    }
+
+    @Override
+    protected void onStop() {
+        getPlayers().forEach(player -> getScore().insertResult(player, scores.getOrDefault(player, 0)));
+    }
+
+    @Override
+    public Pos getSpawn() {
+        double theta = rnd.nextDouble() * 2 * Math.PI;
+
+        double spawnRadius = radius + 2;
+        double x = spawnRadius * Math.cos(theta);
+        double z = spawnRadius * Math.sin(theta);
+
+        return new Pos(x, height + 2, z).withLookAt(new Pos(0, height, 0));
+
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/jumpDive/JumpDiveFactory.java

@@ -0,0 +1,43 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.jumpDive;
+
+import eu.mhsl.minenet.minigames.instance.game.Game;
+import eu.mhsl.minenet.minigames.instance.game.stateless.config.ConfigManager;
+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.game.stateless.config.common.NumericOption;
+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 JumpDiveFactory implements GameFactory {
+    @Override
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_jumpDive#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_jumpDive#description");
+    }
+
+    @Override
+    public ConfigManager configuration() {
+        return new ConfigManager()
+            .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#radius"), 5, 8, 10, 12, 14, 16))
+            .addOption(new NumericOption("height", Material.SCAFFOLDING, TranslatedComponent.byId("optionCommon#height"), 30, 60, 90))
+            .addOption(new NumericOption("timeLimit", Material.CLOCK, TranslatedComponent.byId("optionCommon#seconds"), 60, 120, 180, 240, 300));
+
+    }
+
+    @Override
+    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
+        return new JumpDive(configuration.get("radius").getAsInt(), configuration.get("height").getAsInt(), configuration.get("timeLimit").getAsInt()).setParent(parent);
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.WATER_BUCKET;
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/minerun/MinerunFactory.java

@@ -22,7 +22,7 @@ public class MinerunFactory implements GameFactory {
         return new ConfigManager()
                 .addOption(new NumericOption("width", Material.OAK_FENCE, TranslatedComponent.byId("optionCommon#width"), 10, 30, 50, 100))
                 .addOption(new NumericOption("length", Material.ZOMBIE_HEAD, TranslatedComponent.byId("optionCommon#length"), 50, 100, 150, 200))
-                .addOption(new NumericOption("percentage", Material.LIGHT_WEIGHTED_PRESSURE_PLATE, TranslatedComponent.byId("game_Minerun#optionPercentageMiens"), 30, 40, 50, 60, 70));
+                .addOption(new NumericOption("percentage", Material.LIGHT_WEIGHTED_PRESSURE_PLATE, TranslatedComponent.byId("game_Minerun#optionPercentageMines"), 30, 40, 50, 60, 70));
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/spleef/Spleef.java

@@ -78,6 +78,7 @@ public class Spleef extends StatelessGame {
     }
 
     private void destroyBlock(PlayerStartDiggingEvent event) {
+        if(!isRunning) return;
         setBlock(event.getBlockPosition(), Block.AIR);
     }
 

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/spleef/SpleefFactory.java

@@ -33,7 +33,7 @@ public class SpleefFactory implements GameFactory {
     @Override
     public ConfigManager configuration() {
         return new ConfigManager()
-                .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("game_Spleef#radius"), 10, 20, 30))
+                .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#radius"), 10, 20, 30))
                 .addOption(new NumericOption("stackCount", Material.SCAFFOLDING, TranslatedComponent.byId("game_Spleef#stackCount"), 1, 2, 3, 4, 5));
     }
 

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/stickfight/Stickfight.java

@@ -3,20 +3,23 @@ package eu.mhsl.minenet.minigames.instance.game.stateless.types.stickfight;
 import eu.mhsl.minenet.minigames.instance.Dimension;
 import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
 import eu.mhsl.minenet.minigames.score.LastWinsScore;
-import eu.mhsl.minenet.minigames.util.BatchUtil;
 import eu.mhsl.minenet.minigames.world.generator.terrain.CircularPlateTerrainGenerator;
 import io.github.togar2.pvp.events.FinalAttackEvent;
 import io.github.togar2.pvp.feature.CombatFeatures;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
 import net.minestom.server.event.player.PlayerMoveEvent;
-import net.minestom.server.instance.batch.AbsoluteBlockBatch;
 import net.minestom.server.instance.block.Block;
 import org.jetbrains.annotations.NotNull;
 
+import java.util.List;
+import java.util.WeakHashMap;
 import java.util.concurrent.CompletableFuture;
 
 public class Stickfight extends StatelessGame {
+    private final double radius = 20;
+    private final WeakHashMap<Player, Pos> spawnPoints = new WeakHashMap<>();
+
     public Stickfight() {
         super(Dimension.OVERWORLD.key, "Stickfight", new LastWinsScore());
 
@@ -38,21 +41,56 @@ public class Stickfight extends StatelessGame {
 
     @Override
     protected void onLoad(@NotNull CompletableFuture<Void> callback) {
-        AbsoluteBlockBatch batch = new AbsoluteBlockBatch();
-        for (int z = -10; z <= 10; z++) {
-            batch.setBlock(0, 50, z, Block.SANDSTONE);
-        }
-        batch.setBlock(0, 50, 0, Block.GOLD_BLOCK);
+        setBlock(0, 50, 0, Block.DIAMOND_BLOCK);
+    }
 
-        BatchUtil.loadAndApplyBatch(batch, this, () -> callback.complete(null));
+    @Override
+    protected void start() {
+        List<Player> players = getPlayers().stream().toList();
+        int numPlayers = players.size();
+
+        for (int i = 0; i < numPlayers; i++) {
+            double angle = (2 * Math.PI / numPlayers) * i;
+            int spawnX = (int) (radius * Math.cos(angle));
+            int spawnZ = (int) (radius * Math.sin(angle));
+            int spawnY = 50;
+
+            Pos spawnpoint = new Pos(spawnX, spawnY + 1, spawnZ).add(0.5);
+            spawnPoints.put(players.get(i), spawnpoint.withLookAt(getSpawn()));
+            players.get(i).teleport(spawnpoint);
+
+            generateBridge(spawnX, spawnY, spawnZ);
+        }
+
+        setBlock(0, 50, 0, Block.GOLD_BLOCK);
+        super.start();
+    }
+
+    private void generateBridge(int startX, int startY, int startZ) {
+        int steps = (int) (radius * 1.5);
+        for (int i = 0; i < steps; i++) {
+            double t = (double) i / steps;
+            int x = (int) (startX * (1 - t));
+            int z = (int) (startZ * (1 - t));
+            setBlock(x, startY, z, Block.SANDSTONE);
+        }
     }
 
     @Override
     protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
-        if(isBeforeBeginning) playerMoveEvent.setCancelled(true);
+        if(!spawnPoints.containsKey(playerMoveEvent.getPlayer())) {
+            playerMoveEvent.setCancelled(true);
+            return;
+        }
+
+        if(isBeforeBeginning) {
+            if(spawnPoints.get(playerMoveEvent.getPlayer()).distance(playerMoveEvent.getNewPosition()) < 1) return;
+            playerMoveEvent.setCancelled(true);
+            playerMoveEvent.getPlayer().teleport(spawnPoints.get(playerMoveEvent.getPlayer()));
+        }
 
         if(playerMoveEvent.getNewPosition().y() < 40) {
-            playerMoveEvent.getPlayer().teleport(new Pos(0, 51, 0));
+            playerMoveEvent.getPlayer().teleport(spawnPoints.get(playerMoveEvent.getPlayer()));
         }
     }
 

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/tetris/Tetris.java

@@ -7,7 +7,6 @@ import eu.mhsl.minenet.minigames.instance.game.stateless.types.tetris.game.Tetro
 import eu.mhsl.minenet.minigames.score.PointsWinScore;
 import net.kyori.adventure.text.Component;
 import net.minestom.server.coordinate.Pos;
-import net.minestom.server.coordinate.Vec;
 import net.minestom.server.entity.Entity;
 import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
@@ -73,7 +72,6 @@ class Tetris extends StatelessGame {
     @Override
     protected void onPlayerMove(@NotNull PlayerMoveEvent event) {
         Player player = event.getPlayer();
-        Pos previousPosition = event.getPlayer().getPosition();
         Pos currentPosition = event.getNewPosition();
 
         TetrisGame tetrisGame = this.tetrisGames.get(player);
@@ -85,37 +83,14 @@ class Tetris extends StatelessGame {
         if(tetrisGame.lost) return;
         if(player.getGameMode() == GameMode.SPECTATOR) return;
 
+        if(player.inputs().forward()) tetrisGame.pressedButton(TetrisGame.Button.W);
+        if(player.inputs().backward()) tetrisGame.pressedButton(TetrisGame.Button.S);
+        if(player.inputs().right()) tetrisGame.pressedButton(TetrisGame.Button.D);
+        if(player.inputs().left()) tetrisGame.pressedButton(TetrisGame.Button.A);
+        if(player.inputs().jump()) tetrisGame.pressedButton(TetrisGame.Button.space);
+
         event.setNewPosition(tetrisGame.getPlayerSpawnPosition().withView(currentPosition));
         player.setSprinting(false);
-
-        Vec movementVector = currentPosition.asVec().sub(previousPosition.asVec());
-
-        float yaw = player.getPosition().yaw();
-
-        double yawRadians = Math.toRadians(yaw);
-        double forwardX = -Math.sin(yawRadians);
-        double forwardZ = Math.cos(yawRadians);
-
-        Vec forward = new Vec(forwardX, 0, forwardZ).normalize();
-        Vec left = forward.cross(new Vec(0, 1, 0)).normalize();
-
-        double forwardAmount = movementVector.dot(forward);
-        double leftAmount = movementVector.dot(left);
-
-        double buttonPressAmount = 0.05;
-        if (forwardAmount > buttonPressAmount) {
-            tetrisGame.pressedButton(TetrisGame.Button.W);
-        } else if (forwardAmount < -buttonPressAmount) {
-            tetrisGame.pressedButton(TetrisGame.Button.S);
-        }
-
-        if (leftAmount > buttonPressAmount) {
-            tetrisGame.pressedButton(TetrisGame.Button.D);
-        } else if (leftAmount < -buttonPressAmount) {
-            tetrisGame.pressedButton(TetrisGame.Button.A);
-        }
-
-        if(previousPosition.y() < currentPosition.y()) tetrisGame.pressedButton(TetrisGame.Button.space);
     }
 
     protected void onPlayerInteract(@NotNull PlayerUseItemEvent event) {
@@ -142,9 +117,9 @@ class Tetris extends StatelessGame {
         getScore().insertResult(player, tetrisGame.getScore());
 
         boolean allGamesLost = this.tetrisGames.values().stream()
-                .filter(game -> !game.lost)
-                .toList()
-                .isEmpty();
+            .filter(game -> !game.lost)
+            .toList()
+            .isEmpty();
         if(!setTimeLimit && !allGamesLost) {
             this.setTimeLimit(90);
             setTimeLimit = true;
@@ -158,13 +133,13 @@ class Tetris extends StatelessGame {
 
         if(this.tetrisGames.get(p) == null) {
             this.tetrisGames.put(p, new TetrisGame(
-                    this,
-                    getSpawn().sub(6, 8, 15).add(this.tetrisGames.size()*30, 0, 0),
-                    Tetromino.Shape.J,
-                    this.nextTetrominoesCount,
-                    this.isFast,
-                    this.hasCombat,
-                    this.randomSeed
+                this,
+                getSpawn().sub(6, 8, 15).add(this.tetrisGames.size()*30, 0, 0),
+                Tetromino.Shape.J,
+                this.nextTetrominoesCount,
+                this.isFast,
+                this.hasCombat,
+                this.randomSeed
             ));
             this.tetrisGames.get(p).generate();
             this.tetrisGames.values().forEach(tetrisGame -> tetrisGame.updateOtherTetrisGames(this.tetrisGames.values()));

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/tntrun/TntRun.java

@@ -7,10 +7,7 @@ import eu.mhsl.minenet.minigames.util.BatchUtil;
 import eu.mhsl.minenet.minigames.world.generator.terrain.CircularPlateTerrainGenerator;
 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.metadata.other.PrimedTntMeta;
 import net.minestom.server.event.player.PlayerMoveEvent;
 import net.minestom.server.instance.batch.AbsoluteBlockBatch;
 import net.minestom.server.instance.block.Block;
@@ -51,7 +48,13 @@ public class TntRun extends StatelessGame {
 
     @Override
     protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
+
+
         if(playerMoveEvent.getNewPosition().y() < totalElevation) {
+            if(isBeforeBeginning) {
+                playerMoveEvent.getPlayer().teleport(getSpawn());
+                return;
+            }
             playerMoveEvent.getPlayer().setGameMode(GameMode.SPECTATOR);
             getScore().insertResult(playerMoveEvent.getPlayer());
         }
@@ -67,10 +70,10 @@ public class TntRun extends StatelessGame {
                             setBlock(firstLocation, Block.AIR);
                             setBlock(secondLocation, Block.AIR);
 
-                            Entity fallingTnt = new Entity(EntityType.TNT);
-                            PrimedTntMeta fallingTntMeta = (PrimedTntMeta) fallingTnt.getEntityMeta();
-                            fallingTntMeta.setFuseTime(20);
-                            fallingTnt.setInstance(this, secondLocation);
+//                            Entity fallingTnt = new Entity(EntityType.TNT);
+//                            PrimedTntMeta fallingTntMeta = (PrimedTntMeta) fallingTnt.getEntityMeta();
+//                            fallingTntMeta.setFuseTime(20);
+//                            fallingTnt.setInstance(this, secondLocation);
                         }
                     }
                 }

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/tntrun/TntRunFactory.java

@@ -14,7 +14,12 @@ import java.util.Map;
 public class TntRunFactory implements GameFactory {
     @Override
     public TranslatedComponent name() {
-        return TranslatedComponent.byId("game_tntRun#name");
+        return TranslatedComponent.byId("game_TntRun#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_TntRun#description");
     }
 
     @Override
@@ -25,8 +30,8 @@ public class TntRunFactory implements GameFactory {
     @Override
     public ConfigManager configuration() {
         return new ConfigManager()
-                .addOption(new NumericOption("radius", Material.STICK, TranslatedComponent.byId("game_tntRun#radius"), 20, 30, 50, 60))
-                .addOption(new NumericOption("levels", Material.SCAFFOLDING, TranslatedComponent.byId("game_tntRun#levels"), 1, 2, 3, 4, 5));
+                .addOption(new NumericOption("radius", Material.STICK, TranslatedComponent.byId("optionCommon#radius"), 20, 30, 50, 60))
+                .addOption(new NumericOption("levels", Material.SCAFFOLDING, TranslatedComponent.byId("game_TntRun#levels"), 1, 2, 3, 4, 5));
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/Cursor.java

@@ -0,0 +1,89 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense;
+
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers.Tower;
+import net.minestom.server.coordinate.Point;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.coordinate.Vec;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.entity.Player;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.item.Material;
+import net.minestom.server.network.packet.server.SendablePacket;
+import net.minestom.server.network.packet.server.play.ParticlePacket;
+import net.minestom.server.particle.Particle;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.ArrayList;
+import java.util.Collection;
+
+public class Cursor extends Entity {
+    private boolean cursorActive = false;
+    private final int reach;
+
+    public Cursor(int reach) {
+        super(EntityType.ARMOR_STAND);
+        this.setBoundingBox(0,0,0);
+        this.reach = reach;
+    }
+
+    public void updateCursorPosition(Player player) {
+        Point targetPosition = player.getTargetBlockPosition(this.reach);
+        this.moveCursorTo(targetPosition);
+    }
+
+    private void moveCursorTo(@Nullable Point newTargetBlockPosition) {
+        this.setCursorEnabled(true);
+        if(newTargetBlockPosition == null) {
+            this.setCursorEnabled(false);
+            return;
+        }
+        if(!this.getInstance().getBlock(newTargetBlockPosition).equals(Block.BLACK_WOOL)) this.setCursorEnabled(false);
+        Material holdingMaterial = this.getInstance().getPlayerHandMaterial();
+        if(!this.getInstance().getGame().getAvailableTowers().containsKey(holdingMaterial)) this.setCursorEnabled(false);
+        this.teleport(new Pos(newTargetBlockPosition.add(0.5,1,0.5)));
+        this.showRange(this.getInstance().getGame().getAvailableTowers().get(holdingMaterial));
+    }
+
+    private void setCursorEnabled(boolean enabled) {
+        this.cursorActive = enabled;
+        this.setInvisible(!enabled);
+    }
+
+    private void showRange(@Nullable Class<? extends Tower> towerClass) {
+        if(towerClass == null) return;
+        if(!this.isCursorActive()) return;
+        try {
+            int range = towerClass.getConstructor().newInstance().getRange();
+            Collection<SendablePacket> particles = new ArrayList<>();
+            double circumference = 2 * Math.PI * range;
+            int count = (int) (circumference * 1.5);
+            for (int i = 0; i < count; i++) {
+                double radians = ((2 * Math.PI) / count) * i;
+                Vec relativePosition = new Vec(Math.sin(radians)*range, 0, Math.cos(radians)*range);
+                ParticlePacket particle = new ParticlePacket(Particle.COMPOSTER, this.position.add(relativePosition), Pos.ZERO, 0, 1);
+                particles.add(particle);
+            }
+            this.getInstance().getPlayer().sendPackets(particles);
+        } catch (Exception e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    @Override
+    public TowerdefenseRoom getInstance() {
+        return (TowerdefenseRoom) super.getInstance();
+    }
+
+    public boolean isCursorActive() {
+        return this.cursorActive;
+    }
+
+    public Block getTargetBlock() {
+        return this.getInstance().getBlock(this.getTargetBlockPosition());
+    }
+
+    public Pos getTargetBlockPosition() {
+        return this.getPosition().sub(0, 0.5, 0);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/Towerdefense.java

@@ -2,24 +2,142 @@ package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense;
 
 import eu.mhsl.minenet.minigames.instance.Dimension;
 import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.enemies.WaveGenerator;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.generator.MazeGenerator;
-import eu.mhsl.minenet.minigames.score.NoScore;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers.*;
+import eu.mhsl.minenet.minigames.score.LastWinsScore;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.Player;
-import net.minestom.server.item.ItemStack;
+import net.minestom.server.instance.batch.AbsoluteBlockBatch;
+import net.minestom.server.instance.block.Block;
 import net.minestom.server.item.Material;
+import net.minestom.server.timer.Task;
+import net.minestom.server.timer.TaskSchedule;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Random;
 
 public class Towerdefense extends StatelessGame {
-    public Towerdefense() {
-        super(Dimension.NETHER.key, "Towerdefense", new NoScore());
+    private final Random random = new Random();
+    private final AbsoluteBlockBatch mazeBatch = new AbsoluteBlockBatch();
+    private final List<Pos> mazePath = new ArrayList<>();
+    private final List<TowerdefenseRoom> instances = new ArrayList<>();
+    private final WaveGenerator waveGenerator;
+    private Task waveTask;
+    private final Map<Material, Class<? extends Tower>> availableTowers = Map.of(
+        Material.SKELETON_SPAWN_EGG, SkeletonTower.class,
+        Material.ZOMBIE_SPAWN_EGG, ZombieTower.class,
+        Material.BLAZE_SPAWN_EGG, BlazeTower.class,
+        Material.ENDERMAN_SPAWN_EGG, EndermanTower.class,
+        Material.PIGLIN_BRUTE_SPAWN_EGG, BruteTower.class,
+        Material.WITHER_SPAWN_EGG, WitherTower.class,
+        Material.ENDER_DRAGON_SPAWN_EGG, EnderDragonTower.class
+    );
+    private final Map<Class<? extends Tower>, Integer> prices = Map.of(
+        ZombieTower.class, 4,
+        SkeletonTower.class, 3,
+        BlazeTower.class, 8,
+        EndermanTower.class, 20,
+        BruteTower.class, 27,
+        WitherTower.class, 40,
+        EnderDragonTower.class, 200
+    );
+    private static final int pathLength = 10;
 
-        setGenerator(new MazeGenerator());
+    public Towerdefense() {
+        super(Dimension.NETHER.key, "Towerdefense", new LastWinsScore());
+
+        this.setGenerator(new MazeGenerator());
+        this.generateMaze();
+
+        this.waveGenerator = new WaveGenerator(this);
+    }
+
+    @Override
+    protected void checkAbandoned() {
+        this.scheduleNextTick((instance) -> {
+            if(this.instances.stream().allMatch(room -> room.getPlayers().isEmpty()) && this.getPlayers().isEmpty()) {
+                this.waveTask.cancel();
+                this.unload();
+            }
+        });
+    }
+
+    @Override
+    protected void onStart() {
+        this.getPlayers().forEach(player -> {
+            TowerdefenseRoom newRoom = new TowerdefenseRoom(player, this);
+            this.instances.add(newRoom);
+            player.setInstance(newRoom, new Pos(0, 1, 0));
+        });
+        this.waveTask = MinecraftServer.getSchedulerManager().scheduleTask(
+            this.waveGenerator::startNextWave,
+            TaskSchedule.seconds(3),
+            TaskSchedule.seconds(25)
+        );
+    }
+
+    private void generateMaze() {
+        Pos position = new Pos(0, 0, 0);
+        this.addMazePosition(position, Block.GREEN_WOOL);
+        position = position.add(0,0,2);
+
+        List<Integer> previousDirections = new ArrayList<>();
+        int direction = 1;      // 0 -> right; 1 -> straight; 2 -> left
+        for (int i = 0; i < pathLength; i++) {
+            for (int j = 0; j < 9; j++) {
+                position = position.add(direction-1,0,direction%2);
+                this.addMazePosition(position, Block.WHITE_WOOL);
+            }
+
+            int origin = 0;
+            int bound = 3;
+            long rightLeftDifference = previousDirections.stream().filter(integer -> integer == 0).count() - previousDirections.stream().filter(integer -> integer == 2).count();
+            if(rightLeftDifference >= 2 || direction == 2) origin = 1;
+            if(rightLeftDifference <= -2 || direction == 0) bound = 2;
+            direction = this.random.nextInt(origin, bound);
+            previousDirections.add(direction);
+        }
+        this.addMazePosition(position, Block.WHITE_WOOL);
+        this.addMazePosition(position.add(0,0,3), Block.WHITE_WOOL);
+        this.addMazePosition(position.add(0,0,6), Block.RED_WOOL);
+    }
+
+    private void addMazePosition(Pos position, Block pathBlock) {
+        for (int i = 0; i < 3; i++) {
+            for (int j = 0; j < 3; j++) {
+                this.mazeBatch.setBlock(position.add(i-1,0,j-1), pathBlock);
+            }
+        }
+        this.mazePath.add(position.add(0.5,1,0.5));
+    }
+
+    public AbsoluteBlockBatch getMazeBatch() {
+        return this.mazeBatch;
+    }
+
+    public List<Pos> getMazePath() {
+        return this.mazePath;
+    }
+
+    public List<TowerdefenseRoom> getInstances() {
+        return this.instances;
     }
 
     @Override
     protected boolean onPlayerJoin(Player p) {
-        p.getInventory().setItemStack(1, ItemStack.of(Material.ARMOR_STAND));
-        return false;
+        MinecraftServer.getSchedulerManager().scheduleNextTick(() -> p.teleport(new Pos((long) -this.getPlayers().size(), 1, 0)));
+        return super.onPlayerJoin(p);
     }
 
-    
+    public Map<Class<? extends Tower>, Integer> getPrices() {
+        return this.prices;
+    }
+
+    public Map<Material, Class<? extends Tower>> getAvailableTowers() {
+        return this.availableTowers;
+    }
 }

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/TowerdefenseRoom.java

@@ -0,0 +1,238 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense;
+
+import eu.mhsl.minenet.minigames.instance.Dimension;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.enemies.GroupFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.generator.MazeGenerator;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers.Tower;
+import eu.mhsl.minenet.minigames.util.BatchUtil;
+import eu.mhsl.minenet.minigames.util.CommonEventHandles;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.TextColor;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.collision.Aerodynamics;
+import net.minestom.server.coordinate.Vec;
+import net.minestom.server.entity.*;
+import net.minestom.server.entity.attribute.Attribute;
+import net.minestom.server.entity.damage.DamageType;
+import net.minestom.server.event.entity.EntityDeathEvent;
+import net.minestom.server.event.entity.projectile.ProjectileCollideWithBlockEvent;
+import net.minestom.server.event.entity.projectile.ProjectileCollideWithEntityEvent;
+import net.minestom.server.event.inventory.InventoryPreClickEvent;
+import net.minestom.server.event.item.ItemDropEvent;
+import net.minestom.server.event.item.PlayerBeginItemUseEvent;
+import net.minestom.server.event.player.*;
+import net.minestom.server.instance.InstanceContainer;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.item.ItemAnimation;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+import org.jetbrains.annotations.Nullable;
+
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.UUID;
+
+public class TowerdefenseRoom extends InstanceContainer {
+    private final static int reach = 30;
+    private long lastPlayerAttack = 0;
+    private final Player player;
+    private final Towerdefense game;
+    private final List<EntityCreature> enemies = new ArrayList<>();
+    private final List<Tower> towers = new ArrayList<>();
+    private final Cursor cursor;
+    private int money = 0;
+
+    public TowerdefenseRoom(Player player, Towerdefense game) {
+        super(UUID.randomUUID(), Dimension.OVERWORLD.key);
+        MinecraftServer.getInstanceManager().registerInstance(this);
+        this.player = player;
+        this.game = game;
+        this.player.setGameMode(GameMode.ADVENTURE);
+        this.player.setAllowFlying(true);
+        this.addMoney(0);
+        this.player.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).setBaseValue(reach);
+        this.player.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).setBaseValue(reach);
+
+        this.player.getInventory().addItemStack(
+            ItemStack.of(Material.BOW).withCustomName(Component.text("Schießen", TextColor.color(255, 180, 0)))
+        );
+        this.player.getInventory().addItemStack(
+            ItemStack.of(Material.BARRIER).withCustomName(Component.text("Löschen", TextColor.color(255,0,0)))
+        );
+        this.game.getAvailableTowers().forEach((material, tower) -> {
+            int price = this.game.getPrices().get(tower);
+            this.player.getInventory().addItemStack(ItemStack.of(material).withMaxStackSize(price).withAmount(price));
+        });
+
+        this.setGenerator(new MazeGenerator());
+        BatchUtil.loadAndApplyBatch(this.game.getMazeBatch(), this, () -> {});
+
+        this.cursor = new Cursor(reach);
+        this.cursor.setInstance(this);
+        this.cursor.setBoundingBox(0,0,0);
+
+        this.eventNode()
+            .addListener(EntityDeathEvent.class, event -> {
+                if(!(event.getEntity() instanceof EntityCreature enemy)) return;
+                this.enemies.remove(enemy);
+            })
+            .addListener(PlayerTickEvent.class, event -> this.cursor.updateCursorPosition(this.player))
+            .addListener(PlayerUseItemEvent.class, event -> this.useItem())
+            .addListener(PlayerUseItemOnBlockEvent.class, event -> this.useItem())
+            .addListener(PlayerEntityInteractEvent.class, event -> this.useItem())
+            .addListener(PlayerHandAnimationEvent.class, event -> this.useItem())
+            .addListener(ItemDropEvent.class, CommonEventHandles::cancel)
+            .addListener(InventoryPreClickEvent.class, CommonEventHandles::cancel)
+            .addListener(PlayerSwapItemEvent.class, CommonEventHandles::cancel)
+            .addListener(PlayerBeginItemUseEvent.class, event -> {
+                if(event.getAnimation().equals(ItemAnimation.BOW)) event.setCancelled(true);
+            });
+    }
+
+    private void useItem() {
+        Material itemInHand = this.player.getItemInMainHand().material();
+        if(itemInHand.equals(Material.BOW)) {
+            this.playerAttack();
+            return;
+        }
+        if(itemInHand.equals(Material.BARRIER)) {
+            this.removeTower();
+            return;
+        }
+        this.placeTower();
+    }
+
+    private void playerAttack() {
+        if(this.lastPlayerAttack > System.currentTimeMillis()-200) return;
+        Player p = this.player;
+        this.lastPlayerAttack = System.currentTimeMillis();
+        EntityProjectile projectile = new EntityProjectile(p, EntityType.SPECTRAL_ARROW);
+        projectile.setView(p.getPosition().yaw(), p.getPosition().pitch());
+        projectile.setNoGravity(true);
+        projectile.setAerodynamics(new Aerodynamics(0, 1, 1));
+
+        Vec projectileVelocity = p.getPosition().direction().normalize().mul(20);
+        projectile.setVelocity(projectileVelocity);
+        projectile.scheduleRemove(Duration.ofSeconds(5));
+        projectile.setInstance(this, p.getPosition().add(0, p.getEyeHeight()-0.5, 0));
+        projectile.eventNode()
+            .addListener(ProjectileCollideWithEntityEvent.class, hitEvent -> {
+                if(!(hitEvent.getTarget() instanceof EntityCreature target)) return;
+                if(!this.getEnemies().stream().filter(entityCreature -> !entityCreature.isDead()).toList().contains(target)) return;
+                target.damage(DamageType.PLAYER_ATTACK, 0.1f);
+                if(target.isDead()) this.addMoney((int) target.getAttribute(Attribute.MAX_HEALTH).getBaseValue());
+                projectile.remove();
+            })
+            .addListener(ProjectileCollideWithBlockEvent.class, collisionEvent -> projectile.remove());
+    }
+
+    public void addMoney(int amount) {
+        this.money += amount;
+        this.player.setLevel(this.money);
+    }
+
+    public Material getPlayerHandMaterial() {
+        return this.player.getItemInMainHand().material();
+    }
+
+    private synchronized void placeTower() {
+        if(!this.canPlaceActiveTower()) {
+            if(this.cursor.isCursorActive() && !this.enoughMoneyForActiveTower()) {
+                this.player.sendActionBar(Component.text("Nicht genug Geld!", TextColor.color(255,0,0)));
+            }
+            return;
+        }
+        try {
+            Material usedMaterial = this.player.getItemInMainHand().material();
+            Tower tower = this.game.getAvailableTowers().entrySet().stream()
+                .filter(materialClassEntry -> materialClassEntry.getKey().equals(usedMaterial))
+                .findFirst()
+                .orElseThrow()
+                .getValue()
+                .getConstructor()
+                .newInstance();
+            this.setBlock(this.cursor.getTargetBlockPosition(), Block.BLUE_WOOL);
+            tower.setInstance(this, this.cursor.getPosition());
+            this.towers.add(tower);
+            tower.startShooting();
+            this.addMoney(-this.game.getPrices().get(tower.getClass()));
+        } catch (Exception ignored) {
+        }
+        this.cursor.updateCursorPosition(this.player);
+    }
+
+    private void removeTower() {
+        Entity entity = this.player.getLineOfSightEntity(reach, entity1 -> true);
+        if(!(entity instanceof Tower tower)) return;
+        if(!this.towers.contains(tower)) return;
+
+        this.setBlock(tower.getPosition().sub(0, 0.5, 0), Block.BLACK_WOOL);
+        this.addMoney(tower.getSellingPrice(this.game.getPrices().get(tower.getClass())));
+        this.towers.remove(tower);
+        tower.remove();
+    }
+
+    private boolean canPlaceActiveTower() {
+        Material usedMaterial = this.player.getItemInMainHand().material();
+        return this.canPlaceTower(this.game.getAvailableTowers().get(usedMaterial));
+    }
+
+    private boolean canPlaceTower(@Nullable Class<? extends Tower> towerClass) {
+        if(towerClass == null) return false;
+        return this.cursor.isCursorActive() && this.enoughMoney(towerClass);
+    }
+
+    private boolean enoughMoneyForActiveTower() {
+        Material usedMaterial = this.player.getItemInMainHand().material();
+        return this.enoughMoney(this.game.getAvailableTowers().get(usedMaterial));
+    }
+
+    private boolean enoughMoney(@Nullable Class<? extends Tower> towerClass) {
+        if(towerClass == null) return true;
+        return this.money >= this.game.getPrices().get(towerClass);
+    }
+
+    void startWave(List<GroupFactory> enemyGroups) {
+        enemyGroups.forEach(groupFactory -> groupFactory.summonGroup(this));
+    }
+
+    public void addEnemy(EntityCreature enemy) {
+        enemy.setInstance(this, this.game.getMazePath().getFirst());
+        this.enemies.add(enemy);
+        this.changeEnemyGoal(enemy, 0);
+    }
+
+    private synchronized void changeEnemyGoal(EntityCreature enemy, int positionIndex) {
+        if(positionIndex == this.game.getMazePath().size()-1) {
+            this.enemies.remove(enemy);
+            enemy.remove();
+            float damage = (float) Math.ceil(enemy.getHealth()/10);
+            if(this.player.getHealth() - damage <= 0) {
+                this.getEnemies().forEach(Entity::remove);
+                this.towers.forEach(Entity::remove);
+                this.player.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).setBaseValue(this.player.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).attribute().defaultValue());
+                this.player.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).setBaseValue(this.player.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).attribute().defaultValue());
+                this.player.setInstance(this.game).thenRun(() -> MinecraftServer.getInstanceManager().unregisterInstance(this));
+                this.player.heal();
+                this.game.getScore().insertResult(this.player);
+                return;
+            }
+            this.player.damage(DamageType.PLAYER_ATTACK, damage);
+            return;
+        }
+        enemy.getNavigator().setPathTo(this.game.getMazePath().get(positionIndex+1), 0.6, () -> this.changeEnemyGoal(enemy, positionIndex+1));
+    }
+
+    public Towerdefense getGame() {
+        return this.game;
+    }
+
+    public List<EntityCreature> getEnemies() {
+        return this.enemies;
+    }
+
+    public Player getPlayer() {
+        return this.player;
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/enemies/EnemyFactory.java

@@ -0,0 +1,33 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.enemies;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.entity.attribute.Attribute;
+
+public record EnemyFactory(EntityType entityType, float health, double speed) {
+    /**
+     * Factory for a tower defense enemy.
+     * @param entityType type of enemy
+     * @param health base health (between 0 and 1024, default 10)
+     * @param speed walk speed (default 0.1)
+     */
+    public EnemyFactory {
+        if(health > 1024 || health <= 0) throw new IllegalArgumentException("Enemy health has to be between 0 and 1024");
+    }
+
+    public EnemyFactory(EntityType entityType) {
+        this(entityType, 10, 0.1);
+    }
+
+    public EntityCreature buildEntity() {
+        EntityCreature entity = new EntityCreature(this.entityType);
+        entity.getAttribute(Attribute.MOVEMENT_SPEED).setBaseValue(this.speed);
+        entity.getAttribute(Attribute.MAX_HEALTH).setBaseValue(this.health);
+        entity.setHealth(this.health);
+        return entity;
+    }
+
+    public int getStrength() {
+        return (int) Math.floor(this.health * this.speed * 5);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/enemies/GroupFactory.java

@@ -0,0 +1,16 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.enemies;
+
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.TowerdefenseRoom;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.timer.TaskSchedule;
+
+public record GroupFactory(EnemyFactory enemyFactory, int count, long delay) {
+    public void summonGroup(TowerdefenseRoom instance) {
+        for (int i = 0; i < this.count; i++) {
+            MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+                instance.addEnemy(this.enemyFactory.buildEntity());
+                return TaskSchedule.stop();
+            }, TaskSchedule.millis(this.delay*i));
+        }
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/enemies/WaveGenerator.java

@@ -0,0 +1,77 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.enemies;
+
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.Towerdefense;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.timer.TaskSchedule;
+
+import java.util.*;
+import java.util.concurrent.ThreadLocalRandom;
+import java.util.concurrent.atomic.AtomicInteger;
+
+public class WaveGenerator {
+    final Towerdefense game;
+    int currentLevel;
+    Random random = new Random();
+    private final Map<EnemyFactory, Integer> availableEnemies = Map.of(
+        new EnemyFactory(EntityType.PIG, 2, 0.1), new EnemyFactory(EntityType.PIG, 2, 0.1).getStrength(),
+        new EnemyFactory(EntityType.VILLAGER, 6, 0.1), new EnemyFactory(EntityType.VILLAGER, 6, 0.1).getStrength(),
+        new EnemyFactory(EntityType.SHEEP, 4, 0.2), new EnemyFactory(EntityType.SHEEP, 4, 0.2).getStrength(),
+        new EnemyFactory(EntityType.COW, 10, 0.1), new EnemyFactory(EntityType.COW, 10, 0.1).getStrength(),
+        new EnemyFactory(EntityType.CAMEL, 10, 0.2), new EnemyFactory(EntityType.CAMEL, 10, 0.2).getStrength(),
+        new EnemyFactory(EntityType.ARMADILLO, 20, 0.4), new EnemyFactory(EntityType.ARMADILLO, 20, 0.3).getStrength(),
+        new EnemyFactory(EntityType.CHICKEN, 8, 0.5), new EnemyFactory(EntityType.CHICKEN, 8, 0.6).getStrength()
+    );
+
+    public WaveGenerator(Towerdefense game) {
+        this(game, 1);
+    }
+
+    public WaveGenerator(Towerdefense game, int startLevel) {
+        this.game = game;
+        this.currentLevel = startLevel - 1;
+    }
+
+    public void startNextWave() {
+        this.currentLevel += 1;
+        List<EnemyFactory> enemyList = this.chooseEnemies();
+        Collections.shuffle(enemyList);
+
+        int averageDelay = Math.min(20000 / enemyList.size(), 1500);
+        AtomicInteger delay = new AtomicInteger(0);
+        enemyList.forEach(enemy -> {
+            delay.addAndGet(averageDelay);
+            MinecraftServer.getSchedulerManager().scheduleTask(
+                () -> this.spawnEnemy(enemyList.removeFirst()),
+                TaskSchedule.millis(delay.get() + this.random.nextInt(averageDelay-200, averageDelay+200)),
+                TaskSchedule.stop()
+            );
+        });
+    }
+
+    private void spawnEnemy(EnemyFactory enemy) {
+        this.game.getInstances().forEach(instance -> instance.addEnemy(enemy.buildEntity()));
+    }
+
+    private int getCurrentLevelStrength() {
+        return (int) (0.5 * Math.pow(2, this.currentLevel));
+    }
+
+    private List<EnemyFactory> chooseEnemies() {
+        int strength = this.getCurrentLevelStrength();
+        final List<EnemyFactory> usedEnemies = new ArrayList<>();
+
+        while(strength > 0) {
+            int finalStrength = strength;
+            Map.Entry<EnemyFactory, Integer> chosenEnemy = this.availableEnemies.entrySet().stream()
+                .filter(e -> e.getValue() <= finalStrength)
+                .sorted((o1, o2) -> ThreadLocalRandom.current().nextInt(-1, 2))
+                .findAny()
+                .get();
+            usedEnemies.add(chosenEnemy.getKey());
+            strength -= chosenEnemy.getKey().getStrength();
+        }
+
+        return usedEnemies;
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/BlazeTower.java

@@ -0,0 +1,16 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+
+public class BlazeTower extends ShootingTower {
+    public BlazeTower() {
+        super(EntityType.BLAZE, 2, 2, 15);
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.swingMainHand();
+        this.shootProjectile(enemy, EntityType.FIREBALL, 2, 0);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/BruteTower.java

@@ -0,0 +1,19 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+
+public class BruteTower extends Tower {
+    public BruteTower() {
+        super(EntityType.PIGLIN_BRUTE, 20, 2, 4);
+        this.setItemInMainHand(ItemStack.of(Material.GOLDEN_AXE));
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.swingMainHand();
+        this.causeDamage(enemy);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/EnderDragonTower.java

@@ -0,0 +1,20 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+
+public class EnderDragonTower extends ShootingTower{
+    public EnderDragonTower() {
+        super(EntityType.ENDER_DRAGON, 40, 7, 20);
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.shootProjectile(enemy, EntityType.DRAGON_FIREBALL, 2, 0);
+    }
+
+    @Override
+    protected void onProjectileHit(EntityCreature enemy) {
+        super.onProjectileHit(enemy);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/EndermanTower.java

@@ -0,0 +1,16 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+
+public class EndermanTower extends Tower {
+    public EndermanTower() {
+        super(EntityType.ENDERMAN, 12, 1, 6);
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.swingMainHand();
+        this.causeDamage(enemy);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/ShootingTower.java

@@ -0,0 +1,63 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.collision.Aerodynamics;
+import net.minestom.server.coordinate.Point;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.coordinate.Vec;
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityProjectile;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.entity.attribute.Attribute;
+import net.minestom.server.event.entity.projectile.ProjectileCollideWithBlockEvent;
+import net.minestom.server.event.entity.projectile.ProjectileCollideWithEntityEvent;
+import org.jetbrains.annotations.NotNull;
+
+import java.time.Duration;
+
+public abstract class ShootingTower extends Tower {
+    public ShootingTower(@NotNull EntityType entityType, int damage, double attacksPerSecond, int range) {
+        super(entityType, damage, attacksPerSecond, range);
+    }
+
+    protected void shootProjectile(EntityCreature enemy, EntityType projectileType, double power, double spread) {
+        EntityProjectile projectile = new EntityProjectile(this, projectileType);
+        projectile.setView(this.getPosition().yaw(), this.getPosition().pitch());
+        projectile.setNoGravity(true);
+        projectile.setAerodynamics(new Aerodynamics(0, 1, 1));
+        Pos startingPoint = this.getPosition().add(0, this.getEyeHeight(), 0);
+
+        double enemySpeed = enemy.getAttribute(Attribute.MOVEMENT_SPEED).getBaseValue() / 0.05;
+        Point enemyGoal = enemy.getNavigator().getGoalPosition();
+        if(enemyGoal == null) enemyGoal = enemy.getPosition();
+        Pos enemyPosition = enemy.getPosition();
+        Vec enemyMovement = Vec.fromPoint(enemyGoal.sub(enemyPosition)).normalize().mul(enemySpeed);
+
+        // just an approximation, not calculated correctly:
+        double projectileSpeed = 20 * power;
+        double enemyTowerDistance = startingPoint.distance(enemyPosition);
+        double estimatedFlightTime = (enemyTowerDistance / projectileSpeed);
+        Pos targetPosition = enemyPosition.add(enemyMovement.mul(estimatedFlightTime)).withY(enemyPosition.y()+enemy.getEyeHeight());
+
+        projectile.shoot(targetPosition, power, spread);
+        projectile.scheduleRemove(Duration.ofSeconds(5));
+        projectile.setInstance(this.getInstance(), startingPoint);
+        projectile.eventNode()
+            .addListener(ProjectileCollideWithEntityEvent.class, event -> {
+                if(!(event.getTarget() instanceof EntityCreature target)) return;
+                if(!this.getRoomInstance().getEnemies().contains(target)) return;
+                this.causeDamage(target);
+                this.onProjectileHit(target);
+                target.setFlyingWithElytra(true);
+                projectile.remove();
+            })
+            .addListener(ProjectileCollideWithBlockEvent.class, event -> projectile.remove());
+    }
+
+    protected void onProjectileHit(EntityCreature enemy) {
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.shootProjectile(enemy, EntityType.ARROW, 2, 0);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/SkeletonTower.java

@@ -0,0 +1,25 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+
+public class SkeletonTower extends ShootingTower {
+    public SkeletonTower() {
+        super(EntityType.SKELETON, 1, 2, 10);
+        this.setItemInMainHand(ItemStack.of(Material.BOW));
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.swingMainHand();
+        this.shootProjectile(enemy, EntityType.ARROW, 2, 0);
+    }
+
+    @Override
+    protected void onProjectileHit(EntityCreature enemy) {
+        super.onProjectileHit(enemy);
+//        enemy.getAttribute(Attribute.MOVEMENT_SPEED).setBaseValue(enemy.getAttribute(Attribute.MOVEMENT_SPEED).getBaseValue()*0.5);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/Tower.java

@@ -0,0 +1,135 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.TowerdefenseRoom;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.*;
+import net.minestom.server.entity.attribute.Attribute;
+import net.minestom.server.entity.damage.DamageType;
+import net.minestom.server.timer.Task;
+import net.minestom.server.timer.TaskSchedule;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+public abstract class Tower extends EntityCreature {
+    public enum Priority {
+        FIRST(Type.PATH_DISTANCE),
+        LAST(Type.PATH_DISTANCE),
+        STRONG(Type.HEALTH),
+        WEAK(Type.HEALTH),
+        CLOSE(Type.TOWER_DISTANCE),
+        FAR(Type.TOWER_DISTANCE);
+
+        final Type type;
+        Priority(Type type) {
+            this.type = type;
+        }
+
+        public Type getType() {
+            return this.type;
+        }
+
+        public enum Type {
+            PATH_DISTANCE,
+            HEALTH,
+            TOWER_DISTANCE
+        }
+    }
+
+    private final static int damageDivider = 10;
+    private Priority priority = Priority.FIRST;
+    protected float damage;
+    protected int range;
+    protected double attacksPerSecond;
+    protected TaskSchedule attackDelay;
+    private @Nullable Task attackTask;
+    private float sellingPriceMultiplier = 1;
+
+    public Tower(@NotNull EntityType entityType, int damage, double attacksPerSecond, int range) {
+        super(entityType);
+        this.damage = (float) damage / damageDivider;
+        this.range = range;
+        this.attacksPerSecond = attacksPerSecond;
+        this.attackDelay = TaskSchedule.millis((long) (1000/attacksPerSecond));
+    }
+
+    public void startShooting() {
+        this.attackTask = MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+            EntityCreature nextEnemy = this.getNextEnemy();
+            if(nextEnemy == null) return this.attackDelay;
+            this.lookAt(nextEnemy);
+            this.attack(nextEnemy);
+            return this.attackDelay;
+        }, TaskSchedule.immediate());
+    }
+
+    @Override
+    protected void remove(boolean permanent) {
+        if(this.attackTask != null) this.attackTask.cancel();
+        super.remove(permanent);
+    }
+
+    private @Nullable EntityCreature getNextEnemy() {
+        List<EntityCreature> enemies = this.getSortedEnemies();
+        if(enemies.isEmpty()) return null;
+
+        return switch (this.priority) {
+            case LAST, STRONG, FAR -> enemies.getLast();
+            case FIRST, WEAK, CLOSE -> enemies.getFirst();
+        };
+    }
+
+    private List<EntityCreature> getSortedEnemies() {
+        Stream<EntityCreature> enemyStream = this.getRoomInstance().getEnemies().stream().parallel()
+            .filter(enemy -> !enemy.isDead())
+            .filter(enemy -> enemy.getPosition().distance(this.getPosition()) <= this.range);
+        return switch (this.priority.getType()) {
+            case PATH_DISTANCE -> enemyStream
+                .sorted((o1, o2) -> {
+                    Pos endPoint = this.getRoomInstance().getGame().getMazePath().getLast();
+                    return Double.compare(
+                        o1.getPosition().distance(endPoint),
+                        o2.getPosition().distance(endPoint)
+                    );
+                }).toList();
+            case TOWER_DISTANCE -> enemyStream
+                .sorted((o1, o2) -> Double.compare(
+                    o1.getPosition().distance(this.getPosition()),
+                    o2.getPosition().distance(this.getPosition())
+                )).toList();
+            case HEALTH -> enemyStream
+                .sorted((o1, o2) -> Float.compare(o1.getHealth(), o2.getHealth()))
+                .toList();
+        };
+    }
+
+    protected TowerdefenseRoom getRoomInstance() {
+        return (TowerdefenseRoom) this.getInstance();
+    }
+
+    public int getSellingPrice(int buyPrice) {
+        return (int) (this.sellingPriceMultiplier * buyPrice);
+    }
+
+    public double getValue() {
+        return this.damage * this.attacksPerSecond * this.range * 2;
+    }
+
+    public int getRange() {
+        return this.range;
+    }
+
+    protected void causeDamage(EntityCreature enemy) {
+        this.causeDamage(enemy, this.damage);
+    }
+
+    protected void causeDamage(EntityCreature enemy, float amount) {
+        enemy.damage(DamageType.PLAYER_ATTACK, amount);
+        if(enemy.isDead()) this.getRoomInstance().addMoney((int) enemy.getAttribute(Attribute.MAX_HEALTH).getBaseValue());
+    }
+
+    protected abstract void attack(EntityCreature enemy);
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/WitherTower.java

@@ -0,0 +1,20 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+
+public class WitherTower extends ShootingTower {
+    public WitherTower() {
+        super(EntityType.WITHER, 18, 4, 13);
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.shootProjectile(enemy, EntityType.WITHER_SKULL, 2, 0);
+    }
+
+    @Override
+    protected void onProjectileHit(EntityCreature enemy) {
+        super.onProjectileHit(enemy);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/towerdefense/towers/ZombieTower.java

@@ -0,0 +1,19 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.towers;
+
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+
+public class ZombieTower extends Tower {
+    public ZombieTower() {
+        super(EntityType.ZOMBIE, 7, 1, 4);
+        this.setItemInMainHand(ItemStack.of(Material.IRON_SWORD));
+    }
+
+    @Override
+    protected void attack(EntityCreature enemy) {
+        this.swingMainHand();
+        this.causeDamage(enemy);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/trafficlightrace/TrafficLightRaceFactory.java

@@ -17,6 +17,11 @@ public class TrafficLightRaceFactory implements GameFactory {
         return TranslatedComponent.byId("game_TrafficlightRace#name");
     }
 
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_TrafficlightRace#description");
+    }
+
     @Override
     public ConfigManager configuration() {
         return new ConfigManager()

src/main/java/eu/mhsl/minenet/minigames/instance/room/Room.java

@@ -15,6 +15,7 @@ import net.minestom.server.MinecraftServer;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
+import net.minestom.server.entity.attribute.Attribute;
 import net.minestom.server.event.player.PlayerBlockBreakEvent;
 import net.minestom.server.event.player.PlayerDisconnectEvent;
 import net.minestom.server.instance.anvil.AnvilLoader;
@@ -41,7 +42,7 @@ public class Room extends MineNetInstance implements Spawnable {
     }
 
     public static void deleteRoom(Room room) {
-        logger.info("Deleting room " + room.uniqueId);
+        logger.info("Deleting room " + room.uuid);
         rooms.remove(room);
         players.values().removeAll(Collections.singleton(room));
         room.getAllMembers().forEach(player -> MoveInstance.move(player, Hub.INSTANCE));
@@ -65,6 +66,12 @@ public class Room extends MineNetInstance implements Spawnable {
         p.clearTitle();
         p.getInventory().clear();
         p.setGameMode(GameMode.ADVENTURE);
+        p.setInvisible(false);
+        p.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).setBaseValue(p.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).attribute().defaultValue());
+        p.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).setBaseValue(p.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).attribute().defaultValue());
+        p.heal();
+        p.setExp(0);
+        p.setLevel(0);
         rooms.add(room);
         players.put(p, room);
         MoveInstance.move(p, room);

src/main/java/eu/mhsl/minenet/minigames/lang/Languages.java

@@ -31,7 +31,7 @@ public class Languages {
         return getLanguage(p.getSettings().locale().toString()); // TODO funktioniert die locale noch?
     }
     public Lang getLanguage(String mapId) {
-        return languages.computeIfAbsent(mapId, unused -> languages.computeIfAbsent(defaultLanguage, (key) -> new DummyLang()));
+        return languages.computeIfAbsent(mapId.toLowerCase(), unused -> languages.computeIfAbsent(defaultLanguage, (key) -> new DummyLang()));
     }
 
     private void readAll() {

src/main/java/eu/mhsl/minenet/minigames/shared/entity/InteractableEntity.java

@@ -28,10 +28,6 @@ public class InteractableEntity extends EntityCreature {
                 .addListener(PlayerEntityInteractEvent.class, this::onInteract) //TODO Why are some of these listeners not working?
 
                 .addListener(EntityAttackEvent.class, this::onAttack);
-
-        System.out.println(eventNode().getChildren());
-
-        System.out.println(eventNode().getParent().getChildren());
     }
 
     private void setInstanceEvent(@NotNull AddEntityToInstanceEvent addEntityToInstanceEvent) {

src/main/java/eu/mhsl/minenet/minigames/skin/SkinCache.java

@@ -3,7 +3,6 @@ package eu.mhsl.minenet.minigames.skin;
 import net.minestom.server.MinecraftServer;
 import net.minestom.server.entity.Player;
 import net.minestom.server.entity.PlayerSkin;
-import net.minestom.server.timer.ExecutionType;
 import net.minestom.server.timer.TaskSchedule;
 
 import java.util.HashMap;
@@ -12,19 +11,15 @@ import java.util.Map;
 public class SkinCache {
     private static final Map<String, PlayerSkin> skins = new HashMap<>();
 
-    public static PlayerSkin getSkin(Player p) {
-        return SkinCache.getSkin(p.getUsername());
-    }
-
     public static PlayerSkin getSkin(String p) {
         if(!skins.containsKey(p)) skins.put(p, PlayerSkin.fromUsername(p));
         return skins.get(p);
     }
 
     public static void applySkin(Player p) {
-        MinecraftServer.getSchedulerManager().submitTask(() -> {
+        MinecraftServer.getSchedulerManager().scheduleTask(() -> {
             p.setSkin(SkinCache.getSkin(p.getUsername()));
             return TaskSchedule.stop();
-        }, ExecutionType.TICK_END);
+        }, TaskSchedule.millis(500));
     }
 }

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

@@ -67,7 +67,7 @@ public class SquarePlateTerrainGenerator extends PlateTerrainGenerator {
                 }
 
                 if(generateBorders) {
-                    Runnable generateBorder = () -> unit.modifier().fill(bottom, bottom.add(1, 0, 1), Block.BARRIER); // TODO DimensionType.OVERWORLD.getMaxY() is now hardcoded 0, might break behaviour
+                    Runnable generateBorder = () -> unit.modifier().fill(bottom, bottom.add(1, DimensionType.VANILLA_MAX_Y, 1), Block.BARRIER);
 
                     if(bottom.z() <= length+1 && bottom.z() >= -1 && bottom.x() >= -1 && bottom.x() <= width+1) {
                         if(bottom.x() == -1 || bottom.x() == width+1) {

src/main/resources/lang/locales.map.csv

@@ -23,7 +23,11 @@ other_description;Games which does not fit into other Categories;Spiele welche n
 pvp;Player vs Player;Spieler gegen Spieler
 pvp_description;Fight against other Players;Kämpfe gegen andere Spieler
 pve;Player vs Enviroment;Spieler gegen Umwelt
-pve_description;Surivie the world or fight entities;Überlebe die Welt oder kämpfe gegen Mobs
+pve_description;Survive the world or fight entities;Überlebe die Welt oder kämpfe gegen Mobs
+jumpnrun;jump and run;jump and run
+jumpnrun_description;Proof your jump-and-run skills;Stelle deine jump-and-run Fähigkeiten unter Beweis
+prototype;Prototype;Prototyp
+prototype_description;Prototype games;Prototyp Spiele
 ;;
 ns:hub#;;
 invTitle;MineNet Servernetwork;MineNet Servernetzwerk
@@ -36,7 +40,7 @@ join_notFound;Lobby not found: ;Lobby konnte nicht gefunden werden:
 ;;
 ns:score#;;
 result;Results;Ergebnisse
-thanks;Thank you for Playing;Danke für's spielen
+thanks;Thank you for Playing;Danke für's Spielen
 finish;You did it;Du hast es geschafft
 death;You are out;Du hast verloren
 done;Finish;Fertig
@@ -65,15 +69,26 @@ noOptionDescription;There are no options for this Game;Es gibt keine Einstellung
 ns:GameFactory#;;
 missingDescription;No description;Keine Beschreibung
 ;;
+ns:game_TntRun#;;
+name;TNT run;TNT Rennen
+description;The tnt at the ground disappears, don't fall;Das TNT am Boden verschwindet, falle nicht herunter
+levels;levels;Ebenen
+;;
+ns:game_ElytraRace#;;
+name;Elytra race;Elytra Rennen
+description;Be fast while flying through the rings;Sei schnell während du durch die Ringe fliegst
+ringCount;ring count;Anzahl der Ringe
+;;
 ns:game_Minerun#;;
 name;Minerun;Minenrennen
 description;Ditch deadly Mines in the ground an be the first in the goal;Weiche den tödlichen Bodenmienen aus und sei der erste im Ziel
-optionPercentageMines;Percentage of Miens;Prozentsatz der Minen
+optionPercentageMines;Percentage of mines;Prozentsatz der Minen
 ;;
 ns:game_Deathcube#;;
 name;Deathcube;Todeswürfel
 description;Find a way to jump higher and be the first on the top;Finde einen weg nach oben und sei der erste im Ziel
 optionPercentageBlocks;Percentage of Blocks;Prozentsatz der Blöcke
+optionPvpEnabled;pvp enabled;PvP aktiviert
 ;;
 ns:game_Stickfight#;;
 name;Stickfight;Stockschlacht
@@ -83,6 +98,14 @@ ns:game_TrafficlightRace#;;
 name;Red light green light;Rotes licht, Grünes licht
 description;Only go forward if the Trafficlights show green;Gehe nur bei Grün vorran
 ;;
+ns:game_AcidRain#;;
+name;Acid rain;Säureregen
+description;Stay under the holey roof to dodge acid rain;Bleib unter dem löchrigen Dach um dem sauren Regen auszuweichen
+;;
+ns:game_BowSpleef#;;
+name;Bow spleef;Bogen Spleef
+description;Spleef other players and be the last survivor;Zerstöre Blöcke unter anderen Spielern und sei der letzte im Feld
+;;
 ns:game_Towerdefense#;;
 name;Towerdefense;Towerdefense
 description;Protect the path ????;??????
@@ -91,6 +114,7 @@ ns:game_Spleef#;;
 name;Spleef;Spleef;
 description;Spleef other players and be the last survivor;Zerstöre Blöcke unter anderen Spielern und sei der letzte im Feld
 shovelName;Snow thrower;Schneeflug
+stackCount;levels;Ebenen
 ;;
 ns:game_Tetris#;;
 name;Tetris;Tetris
@@ -100,5 +124,9 @@ isFast;Fast mode;Schneller Modus
 hasCombat;Competitive mode;Kompetitiver Modus
 ;;
 ns:game_AnvilRun#;;
-name;Anvil Run;Anvil Run
-description;Run away from falling anvils;Renne von fallenden Ambossen davon
+name;Anvil run;Anvil run
+description;Run away from falling anvils;Renne von fallenden Ambossen davon
+;;
+ns:game_jumpDive#;;
+name;Jump dive;Wassersprung
+description;Jump into the water, avoiding already used spots!;Springe ins wasser an stellen, in denen noch niemand zuvor gelandet ist!