added turtle game to pve

# Conflicts:
#	build.gradle
#	src/main/java/eu/mhsl/minenet/minigames/instance/game/GameList.java

build.gradle

@@ -48,7 +48,7 @@ dependencies {
 
     //Tools
     implementation 'de.articdive:jnoise:3.0.2'
-    implementation 'net.md-5:bungeecord-config:1.19-R0.1-SNAPSHOT'
+    implementation 'net.md-5:bungeecord-config:1.21-R0.3'
     implementation 'org.apache.commons:commons-text:1.10.0'
     implementation 'org.spongepowered:configurate-yaml:4.1.2'
     implementation 'com.sparkjava:spark-core:2.9.4'

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

@@ -3,20 +3,23 @@ package eu.mhsl.minenet.minigames.instance.game;
 import eu.mhsl.minenet.minigames.instance.game.stateless.config.GameFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.anvilRun.AnvilRunFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.bowSpleef.BowSpleefFactory;
-import eu.mhsl.minenet.minigames.instance.game.stateless.types.buildBattle.BuildBattleFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.elytraRace.ElytraRaceFactory;
 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.acidRain.AcidRainFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.deathcube.DeathcubeFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.fastbridge.FastbridgeFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.highGround.HighGroundFactory;
 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;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.tetris.TetrisFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.sumo.SumoFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.tntrun.TntRunFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.towerdefense.TowerdefenseFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.trafficlightrace.TrafficLightRaceFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.turtleGame.TurtleGameFactory;
 
 public enum GameList {
     DEATHCUBE(new DeathcubeFactory(), GameType.JUMPNRUN),
@@ -31,10 +34,13 @@ public enum GameList {
     TNTRUN(new TntRunFactory(), GameType.OTHER),
     ANVILRUN(new AnvilRunFactory(), GameType.PVE),
     ACIDRAIN(new AcidRainFactory(), GameType.PVE),
+    TURTLEGAME(new TurtleGameFactory(), GameType.PVE),
     ELYTRARACE(new ElytraRaceFactory(), GameType.PVP),
     SPLEEF(new SpleefFactory(), GameType.PVP),
     JUMPDIVE(new JumpDiveFactory(), GameType.JUMPNRUN),
-    BUILDBATTLE(new BuildBattleFactory(), GameType.OTHER);
+    SUMO(new SumoFactory(), GameType.PVP),
+    HIGHGROUND(new HighGroundFactory(), GameType.PVP),
+    FASTBRIDGE(new FastbridgeFactory(), GameType.OTHER);
 
     private final GameFactory factory;
     private final GameType type;
@@ -47,6 +53,6 @@ public enum GameList {
     }
 
     public GameType getType() {
-        return type;
+        return this.type;
     }
 }

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/anvilRun/AnvilRunFactory.java

@@ -26,7 +26,7 @@ public class AnvilRunFactory implements GameFactory {
     public ConfigManager configuration() {
         return new ConfigManager()
             .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#radius"), 5, 10, 15, 20, 25, 30))
-            .addOption(new NumericOption("seconds", Material.STICK, TranslatedComponent.byId("optionCommon#seconds"), 10, 30, 60, 90, 120));
+            .addOption(new NumericOption("seconds", Material.CLOCK, TranslatedComponent.byId("optionCommon#seconds"), 10, 30, 60, 90, 120));
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/buildBattle/BuildBattle.java

@@ -1,13 +0,0 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.buildBattle;
-
-import eu.mhsl.minenet.minigames.instance.Dimension;
-import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
-import eu.mhsl.minenet.minigames.score.NoScore;
-
-public class BuildBattle extends StatelessGame {
-    public BuildBattle() {
-        super(Dimension.OVERWORLD.key, "buildBattle", new NoScore());
-    }
-
-
-}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/buildBattle/BuilderWorld.java

@@ -1,12 +0,0 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.buildBattle;
-
-import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
-import eu.mhsl.minenet.minigames.score.Score;
-import net.minestom.server.registry.DynamicRegistry;
-import net.minestom.server.world.DimensionType;
-
-class BuilderWorld extends StatelessGame {
-    public BuilderWorld(DynamicRegistry.Key<DimensionType> dimensionType, String gameName, Score score) {
-        super(dimensionType, gameName, score);
-    }
-}

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

@@ -8,6 +8,7 @@ import eu.mhsl.minenet.minigames.world.BlockPallet;
 import eu.mhsl.minenet.minigames.world.generator.terrain.CircularPlateTerrainGenerator;
 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 org.jetbrains.annotations.NotNull;

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/fastbridge/Fastbridge.java

@@ -0,0 +1,64 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.fastbridge;
+
+import eu.mhsl.minenet.minigames.instance.Dimension;
+import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
+import eu.mhsl.minenet.minigames.score.FirstWinsScore;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.GameMode;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.player.PlayerBlockPlaceEvent;
+import net.minestom.server.event.player.PlayerMoveEvent;
+import net.minestom.server.instance.Chunk;
+import net.minestom.server.inventory.PlayerInventory;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+import org.jetbrains.annotations.NotNull;
+
+public class Fastbridge extends StatelessGame {
+    private int currentSpawn = 0;
+
+    public Fastbridge() {
+        super(Dimension.OVERWORLD.key, "Fastbridge", new FirstWinsScore());
+        this.setGenerator(new FastbridgeChunkgenerator());
+    }
+
+    @Override
+    protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
+        Player player = playerMoveEvent.getPlayer();
+        Pos newPos = playerMoveEvent.getNewPosition();
+        if(this.getScore().hasResult(player)) return;
+        if(newPos.y() < 0) {
+            player.teleport(getSpawn());
+            if(!isBeforeBeginning) this.resetPlayer(player);
+        }
+        if(newPos.x() > 53) {
+            this.getScore().insertResult(player);
+            player.setGameMode(GameMode.SPECTATOR);
+        }
+    }
+
+    @Override
+    protected void onStart() {
+        getPlayers().forEach(player -> {
+            player.setGameMode(GameMode.SURVIVAL);
+            resetPlayer(player);
+        });
+    }
+
+    @Override
+    protected void onBlockPlace(@NotNull PlayerBlockPlaceEvent playerBlockPlaceEvent) {
+        if(isBeforeBeginning) playerBlockPlaceEvent.setCancelled(true);
+    }
+
+    private void resetPlayer(Player player) {
+        if(isBeforeBeginning) return;
+        PlayerInventory inventory = player.getInventory();
+        inventory.clear();
+        inventory.addItemStack(ItemStack.of(Material.WHITE_WOOL, 64));
+    }
+
+    @Override
+    public synchronized Pos getSpawn() {
+        return new Pos(24, 1, currentSpawn++*Chunk.CHUNK_SIZE_Z*2-8, -90, 0);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/fastbridge/FastbridgeChunkgenerator.java

@@ -0,0 +1,29 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.fastbridge;
+
+import eu.mhsl.minenet.minigames.world.generator.featureEnriched.ValeGenerator;
+import eu.mhsl.minenet.minigames.world.generator.terrain.BaseGenerator;
+import net.minestom.server.instance.block.Block;
+
+public class FastbridgeChunkgenerator extends BaseGenerator {
+    public FastbridgeChunkgenerator() {
+        this.addMixIn(unit -> {
+            if (unit.absoluteStart().chunkZ() % 2 == 0) {
+                unit.modifier().fill(Block.BARRIER);
+                return;
+            }
+
+            if (unit.absoluteStart().chunkX() != 1 && unit.absoluteStart().chunkX() != 3) return;
+            for (int x = 5; x <= 10; x++){
+                for (int z = 5; z <= 10; z++){
+                    unit.modifier().setRelative(x, 64, z, unit.absoluteStart().chunkX() == 3 ? Block.GOLD_BLOCK : Block.GRASS_BLOCK);
+                }
+            }
+        });
+
+        ValeGenerator vale = new ValeGenerator();
+        vale.setXShiftMultiplier(integer -> 0.5d);
+        vale.setHeightNoiseMultiplier(integer -> 2);
+        vale.setXShiftOffset(integer -> 40d);
+        this.addMixIn(vale);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/fastbridge/FastbridgeFactory.java

@@ -1,21 +1,33 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.buildBattle;
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.fastbridge;
 
 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 BuildBattleFactory implements GameFactory {
+public class FastbridgeFactory implements GameFactory {
+
     @Override
     public TranslatedComponent name() {
-        return TranslatedComponent.byId("game_BuildBattle#name");
+        return TranslatedComponent.byId("game_Fastbridge#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_Fastbridge#description");
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.WHITE_WOOL;
     }
 
     @Override
     public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
-        return new BuildBattle();
+        return new Fastbridge().setParent(parent);
     }
 }

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

@@ -0,0 +1,126 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.highGround;
+
+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.world.BlockPallet;
+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 net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.Player;
+import net.minestom.server.event.instance.InstanceTickEvent;
+import net.minestom.server.event.player.PlayerMoveEvent;
+import net.minestom.server.instance.block.Block;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.WeakHashMap;
+import java.util.concurrent.CompletableFuture;
+
+class HighGround extends StatelessGame {
+    private final int radius;
+    private final int seconds;
+    private final WeakHashMap<Player, Integer> scoreMap = new WeakHashMap<>();
+
+    HighGround(int radius, int seconds) {
+        super(Dimension.THE_END.key, "highground", new PointsWinScore());
+        this.radius = radius;
+        this.seconds = seconds;
+
+        this.eventNode().addChild(
+            CombatFeatures.empty()
+                .add(CombatFeatures.VANILLA_ATTACK)
+                .add(CombatFeatures.VANILLA_DAMAGE)
+                .add(CombatFeatures.VANILLA_KNOCKBACK)
+                .build()
+                .createNode()
+        );
+
+        this.eventNode().addListener(
+            FinalAttackEvent.class,
+            finalAttackEvent -> finalAttackEvent.setBaseDamage(0)
+        );
+
+        this.eventNode().addListener(PrepareAttackEvent.class, prepareAttackEvent -> {
+            if(this.isBeforeBeginning){
+                prepareAttackEvent.setCancelled(true);
+            }
+        });
+
+        this.eventNode().addListener(
+            EntityKnockbackEvent.class,
+            entityKnockbackEvent -> entityKnockbackEvent.setStrength(1.1f)
+        );
+
+        this.eventNode().addListener(InstanceTickEvent.class, instanceTickEvent ->  {
+            if (this.isBeforeBeginning || !this.isRunning) return;
+            this.getPlayers().forEach(player -> {
+                if((player.isOnGround() && player.getPosition().y() >= 1) || (!player.isOnGround() && player.getPosition().y() >= 1.5)){
+                    this.scoreMap.put(player, this.scoreMap.get(player) + 1);
+                    player.setLevel(this.scoreMap.get(player) / 20);
+                    player.setExp((this.scoreMap.get(player) % 20) / 20.0f);
+                }
+            });
+        });
+    }
+
+    @Override
+    protected void onLoad(@NotNull CompletableFuture<Void> callback) {
+        for (int y = 0; y >= -3; y--) {
+            int radius = (Math.abs(y) * 5) + this.radius;
+            for (int x = -radius; x <= radius; x++) {
+                for (int z = -radius; z <= radius; z++) {
+                    double distance = new Pos(x, 0, z).distance(0, 0, 0);
+                    if (distance <= radius) {
+                        this.setBlock(x, y, z, y == 0 ? Block.DIAMOND_BLOCK : Block.GRASS_BLOCK);
+                        Pos featurePosition = new Pos(x, y + 1, z);
+
+                        if(y >= 0 || this.getBlock(featurePosition).isSolid()) continue;
+                        if (this.rnd.nextDouble() < 0.1){
+                            this.setBlock(featurePosition, Block.SHORT_GRASS);
+                        }
+                        if (this.rnd.nextDouble() < 0.01){
+                            this.setBlock(featurePosition, BlockPallet.FLOWER.rnd());
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    @Override
+    protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
+        Player player = playerMoveEvent.getPlayer();
+        if(playerMoveEvent.getNewPosition().y() < -10){
+            player.teleport(this.getSpawn());
+        }
+    }
+
+    @Override
+    protected void start() {
+        this.getPlayers().forEach(player -> this.scoreMap.put(player, 0));
+        super.start();
+    }
+
+    @Override
+    protected void onStart() {
+        this.setTimeLimit(this.seconds);
+    }
+
+    @Override
+    protected void onStop() {
+        this.getPlayers().forEach(player -> this.getScore().insertResult(player, this.scoreMap.get(player)));
+    }
+
+    @Override
+    public Pos getSpawn() {
+        double theta = this.rnd.nextDouble() * 2 * Math.PI;
+
+        double spawnRadius = this.radius + 5;
+        double x = spawnRadius * Math.cos(theta);
+        double z = spawnRadius * Math.sin(theta);
+
+        return new Pos(x, 0, z).withLookAt(new Pos(0, 0, 0));
+    }
+}

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

@@ -0,0 +1,41 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.highGround;
+
+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 HighGroundFactory implements GameFactory {
+    @Override
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_Highground#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_Highground#description");
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.GOLDEN_HELMET;
+    }
+
+    @Override
+    public ConfigManager configuration() {
+        return new ConfigManager()
+                .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#radius"), 3, 5, 7, 10))
+                .addOption(new NumericOption("seconds", Material.CLOCK, TranslatedComponent.byId("optionCommon#seconds"), 30, 60, 90, 120));
+    }
+
+    @Override
+    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
+        return new HighGround(configuration.get("radius").getAsInt(), configuration.get("seconds").getAsInt()).setParent(parent);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/sumo/Sumo.java

@@ -0,0 +1,129 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.sumo;
+
+import eu.mhsl.minenet.minigames.instance.Dimension;
+import eu.mhsl.minenet.minigames.instance.game.stateless.StatelessGame;
+import eu.mhsl.minenet.minigames.score.LastWinsScore;
+import io.github.togar2.pvp.events.FinalAttackEvent;
+import io.github.togar2.pvp.events.PrepareAttackEvent;
+import io.github.togar2.pvp.feature.CombatFeatures;
+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.player.PlayerMoveEvent;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.timer.TaskSchedule;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.WeakHashMap;
+import java.util.concurrent.CompletableFuture;
+
+public class Sumo extends StatelessGame {
+    int radius;
+    int health;
+    int seconds;
+
+    int originalRadius;
+    int timer;
+
+    WeakHashMap<Player, Integer> healthMap = new WeakHashMap<>();
+
+    public Sumo(int radius, int health, int seconds) {
+        super(Dimension.OVERWORLD.key, "Sumo", new LastWinsScore());
+        this.getScore().setIgnoreLastPlayers(1);
+        this.setTime(6000);
+        this.setTimeRate(0);
+
+        this.radius = radius;
+        this.health = health;
+        this.seconds = seconds;
+
+        this.originalRadius = radius;
+        this.timer = seconds;
+
+        this.eventNode().addChild(
+                CombatFeatures.empty()
+                        .add(CombatFeatures.VANILLA_ATTACK)
+                        .add(CombatFeatures.VANILLA_DAMAGE)
+                        .add(CombatFeatures.VANILLA_KNOCKBACK)
+                        .build()
+                        .createNode()
+        );
+
+        this.eventNode().addListener(PrepareAttackEvent.class, prepareAttackEvent -> {
+            if (this.isBeforeBeginning)
+                prepareAttackEvent.setCancelled(true);
+        });
+
+        this.eventNode().addListener(FinalAttackEvent.class, finalAttackEvent -> {
+            finalAttackEvent.setBaseDamage(0);
+            ((Player) finalAttackEvent.getTarget()).setHealth(20);
+        });
+    }
+
+    @Override
+    protected void start() {
+        this.getPlayers().forEach(player -> {
+            this.healthMap.put(player, this.health);
+            player.setLevel(this.healthMap.get(player));
+        });
+
+        MinecraftServer.getSchedulerManager().scheduleTask(
+            () -> {
+                if(this.isBeforeBeginning) return TaskSchedule.seconds(1);
+                this.timer--;
+                double percent = (double) this.timer / this.seconds;
+                int radius = (int) (this.originalRadius * percent);
+                if (this.radius >= 5) {
+                    this.radius = radius;
+                    this.generatePlatform();
+                    return TaskSchedule.seconds(1);
+                }
+
+                return TaskSchedule.stop();
+            },
+            TaskSchedule.seconds(1)
+        );
+
+        super.start();
+    }
+
+    @Override
+    protected void onLoad(@NotNull CompletableFuture<Void> callback) {
+        this.generatePlatform();
+    }
+
+    private void generatePlatform() {
+        int buffer = 5;
+        for(int x = -this.radius - buffer; x <= this.radius + buffer; x++) {
+            for(int z = -this.radius - buffer; z <= this.radius + buffer; z++) {
+                double distance = new Pos(x, 0, z).distance(new Pos(0, 0, 0));
+                if(distance <= this.radius) {
+                    boolean isEdge = this.radius - 1 < distance;
+                    this.setBlock(x, 0, z, isEdge ? Block.RED_CONCRETE : Block.WHITE_CONCRETE);
+                } else {
+                    this.setBlock(x, 0, z, Block.AIR);
+                }
+            }
+        }
+    }
+
+    @Override
+    protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
+        Player player = playerMoveEvent.getPlayer();
+        if(playerMoveEvent.getNewPosition().y() < -10) {
+            player.teleport(this.getSpawn());
+            this.healthMap.put(player, this.healthMap.get(player) - 1);
+            player.setLevel(this.healthMap.get(player));
+            if (this.healthMap.get(player) == 0) {
+                this.getScore().insertResult(player);
+                player.setGameMode(GameMode.SPECTATOR);
+            }
+        }
+    }
+
+    @Override
+    public Pos getSpawn() {
+        return  new Pos(0, 2, 0);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/sumo/SumoFactory.java

@@ -0,0 +1,41 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.sumo;
+
+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 SumoFactory implements GameFactory {
+    @Override
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_Sumo#name");
+    }
+
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_Sumo#description");
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.SLIME_BALL;
+    }
+
+    @Override
+    public ConfigManager configuration() {
+        return new ConfigManager()
+                .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#radius"), 10, 20, 30))
+                .addOption(new NumericOption("health", Material.GOLDEN_APPLE, TranslatedComponent.byId("game_Sumo#lives"), 1, 2, 3, 4, 5))
+                .addOption(new NumericOption("seconds", Material.CLOCK, TranslatedComponent.byId("optionCommon#seconds"), 30, 60, 90, 120));
+    }
+
+    @Override
+    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
+        return new Sumo(configuration.get("radius").getAsInt(), configuration.get("health").getAsInt(), configuration.get("seconds").getAsInt()).setParent(parent);
+    }
+}

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

@@ -28,7 +28,7 @@ class Tetris extends StatelessGame {
     public Tetris(int nextTetrominoesCount, boolean isFast, boolean hasCombat) {
         super(Dimension.THE_END.key, "Tetris", new PointsWinScore());
 
-        eventNode()
+        this.eventNode()
             .addListener(PlayerUseItemEvent.class, this::onPlayerInteract)
             .addListener(PlayerHandAnimationEvent.class, this::onPlayerAttack)
             .addListener(PlayerTickEvent.class, this::onPlayerTick);
@@ -58,7 +58,7 @@ class Tetris extends StatelessGame {
     protected void onStop() {
         this.tetrisGames.forEach((player, tetrisGame) -> {
             tetrisGame.loose();
-            getScore().insertResult(player, tetrisGame.getScore());
+            this.getScore().insertResult(player, tetrisGame.getScore());
             tetrisGame.sidebar.removeViewer(player);
         });
     }
@@ -106,23 +106,25 @@ class Tetris extends StatelessGame {
         TetrisGame tetrisGame = this.tetrisGames.get(player);
         if(tetrisGame == null) return;
         if(tetrisGame.lost && player.getGameMode() != GameMode.SPECTATOR) {
-            letPlayerLoose(player);
+            this.letPlayerLoose(player);
         }
     }
 
     private void letPlayerLoose(Player player) {
         TetrisGame tetrisGame = this.tetrisGames.get(player);
+        if(!this.getScore().hasResult(player)) {
             player.setGameMode(GameMode.SPECTATOR);
             player.setInvisible(true);
-        getScore().insertResult(player, tetrisGame.getScore());
+            this.getScore().insertResult(player, tetrisGame.getScore());
+        }
 
         boolean allGamesLost = this.tetrisGames.values().stream()
             .filter(game -> !game.lost)
             .toList()
             .isEmpty();
-        if(!setTimeLimit && !allGamesLost) {
+        if(!this.setTimeLimit && !allGamesLost) {
             this.setTimeLimit(90);
-            setTimeLimit = true;
+            this.setTimeLimit = true;
         }
     }
 
@@ -134,7 +136,7 @@ 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),
+                this.getSpawn().sub(6, 8, 15).add(this.tetrisGames.size()*30, 0, 0),
                 Tetromino.Shape.J,
                 this.nextTetrominoesCount,
                 this.isFast,

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

@@ -74,10 +74,10 @@ public class Playfield {
             }
         }
 
-        batch.setBlock(getPlayerSpawnPosition().sub(0, 1, 0), Block.STONE);
+        batch.setBlock(this.getPlayerSpawnPosition().sub(0, 1, 0), Block.STONE);
-        batch.setBlock(getPlayerSpawnPosition().sub(1, 1, 0), Block.STONE);
+        batch.setBlock(this.getPlayerSpawnPosition().sub(1, 1, 0), Block.STONE);
-        batch.setBlock(getPlayerSpawnPosition().sub(1, 1, 1), Block.STONE);
+        batch.setBlock(this.getPlayerSpawnPosition().sub(1, 1, 1), Block.STONE);
-        batch.setBlock(getPlayerSpawnPosition().sub(0, 1, 1), Block.STONE);
+        batch.setBlock(this.getPlayerSpawnPosition().sub(0, 1, 1), Block.STONE);
 
         BatchUtil.loadAndApplyBatch(batch, this.instance, () -> {});
     }
@@ -90,7 +90,7 @@ public class Playfield {
                 if(this.instance.getBlock(this.lowerLeftCorner.add(x, y, 1)) == Block.AIR) isFullLine = false;
             }
             if(isFullLine) {
-                removeFullLine(y);
+                this.removeFullLine(y);
                 removedLinesCounter += 1;
                 y -= 1;
             }
@@ -99,10 +99,10 @@ public class Playfield {
     }
 
     public void addLines(int lines) {
-        int xPosMissing = random.nextInt(1, 10);
+        int xPosMissing = this.random.nextInt(1, 10);
 
         for (int i = 0; i < lines; i++) {
-            moveAllLinesUp();
+            this.moveAllLinesUp();
             for (int x = 1; x < 11; x++) {
                 if(x != xPosMissing) {
                     this.instance.setBlock(this.lowerLeftCorner.add(x, 1, 1), Block.LIGHT_GRAY_CONCRETE);

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

@@ -121,8 +121,8 @@ public class TetrisGame {
 
     public void tick() {
         if(this.lost || this.paused) return;
-        if(!currentTetromino.moveDown()) {
+        if(!this.currentTetromino.moveDown()) {
-            setActiveTetrominoDown();
+            this.setActiveTetrominoDown();
         }
     }
 
@@ -176,7 +176,7 @@ public class TetrisGame {
     }
 
     private boolean switchHold() {
-        if(!holdPossible) return false;
+        if(!this.holdPossible) return false;
 
         Tetromino newCurrentTetromino;
         if(this.holdTetromino == null) {
@@ -194,7 +194,7 @@ public class TetrisGame {
 
         this.currentTetromino.setPosition(this.tetrominoSpawnPosition);
         this.currentTetromino.draw();
-        if(!this.currentTetromino.moveDown()) loose();
+        if(!this.currentTetromino.moveDown()) this.loose();
 
         double xChange = this.holdTetromino.getXChange();
         this.holdTetromino.setPosition(this.holdPosition.add(xChange, 0, 0));
@@ -312,7 +312,7 @@ public class TetrisGame {
         this.currentTetromino.setPosition(this.tetrominoSpawnPosition);
         this.currentTetromino.draw();
         if(!this.currentTetromino.moveDown()) {
-            loose();
+            this.loose();
         }
     }
 }

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

@@ -38,13 +38,13 @@ public class Tetromino {
         this.uuid = UUID.randomUUID();
 
         switch (this.shape) {
-            case I -> shapeArray = new int[][]{{0, 0, 0, 0}, {1, 1, 1, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+            case I -> this.shapeArray = new int[][]{{0, 0, 0, 0}, {1, 1, 1, 1}, {0, 0, 0, 0}, {0, 0, 0, 0}};
-            case J -> shapeArray = new int[][]{{1,0,0}, {1,1,1}, {0,0,0}};
+            case J -> this.shapeArray = new int[][]{{1,0,0}, {1,1,1}, {0,0,0}};
-            case L -> shapeArray = new int[][]{{0,0,1}, {1,1,1}, {0,0,0}};
+            case L -> this.shapeArray = new int[][]{{0,0,1}, {1,1,1}, {0,0,0}};
-            case O -> shapeArray = new int[][]{{1,1}, {1,1}};
+            case O -> this.shapeArray = new int[][]{{1,1}, {1,1}};
-            case S -> shapeArray = new int[][]{{0,1,1}, {1,1,0}, {0,0,0}};
+            case S -> this.shapeArray = new int[][]{{0,1,1}, {1,1,0}, {0,0,0}};
-            case T -> shapeArray = new int[][]{{0,1,0}, {1,1,1}, {0,0,0}};
+            case T -> this.shapeArray = new int[][]{{0,1,0}, {1,1,1}, {0,0,0}};
-            case Z -> shapeArray = new int[][]{{1,1,0}, {0,1,1}, {0,0,0}};
+            case Z -> this.shapeArray = new int[][]{{1,1,0}, {0,1,1}, {0,0,0}};
         }
     }
 
@@ -58,22 +58,22 @@ public class Tetromino {
 
     public boolean rotate(boolean clockwise) {
         int[][] newShapeArray = this.getTurnedShapeArray(clockwise);
-        return checkCollisionAndMove(this.position, newShapeArray);
+        return this.checkCollisionAndMove(this.position, newShapeArray);
     }
 
     public boolean moveDown() {
         Pos newPosition = this.position.sub(0, 1, 0);
-        return checkCollisionAndMove(newPosition, this.shapeArray);
+        return this.checkCollisionAndMove(newPosition, this.shapeArray);
     }
 
     public boolean moveLeft() {
         Pos newPosition = this.position.sub(1, 0, 0);
-        return checkCollisionAndMove(newPosition, this.shapeArray);
+        return this.checkCollisionAndMove(newPosition, this.shapeArray);
     }
 
     public boolean moveRight() {
         Pos newPosition = this.position.add(1, 0, 0);
-        return checkCollisionAndMove(newPosition, this.shapeArray);
+        return this.checkCollisionAndMove(newPosition, this.shapeArray);
     }
 
     public void draw() {
@@ -83,11 +83,11 @@ public class Tetromino {
     public void draw(boolean withGhost) {
         if(withGhost) {
             Pos ghostPos = this.position;
-            while (!checkCollision(ghostPos.sub(0, 1, 0), this.shapeArray)) {
+            while (!this.checkCollision(ghostPos.sub(0, 1, 0), this.shapeArray)) {
                 ghostPos = ghostPos.sub(0, 1, 0);
             }
             Pos positionChange = this.position.sub(ghostPos);
-            getBlockPositions().forEach(pos -> {
+            this.getBlockPositions().forEach(pos -> {
                 Entity ghostBlock = new Entity(ghostEntityType);
                 ((FallingBlockMeta) ghostBlock.getEntityMeta()).setBlock(this.getGhostBlock());
                 ghostBlock.setNoGravity(true);
@@ -97,11 +97,11 @@ public class Tetromino {
             });
         }
 
-        getBlockPositions().forEach(pos -> this.instance.setBlock(pos, this.getColoredBlock()));
+        this.getBlockPositions().forEach(pos -> this.instance.setBlock(pos, this.getColoredBlock()));
     }
 
     public void drawAsEntities() {
-        getBlockPositions().forEach(pos -> {
+        this.getBlockPositions().forEach(pos -> {
             Entity ghostBlock = new Entity(ghostEntityType);
             ((FallingBlockMeta) ghostBlock.getEntityMeta()).setBlock(this.getColoredBlock());
             ghostBlock.setNoGravity(true);
@@ -222,10 +222,10 @@ public class Tetromino {
     }
 
     private boolean checkCollision(Pos newPosition, int[][] newShapeArray) {
-        List<Pos> newBlockPositions = getBlockPositions(newPosition, newShapeArray);
+        List<Pos> newBlockPositions = this.getBlockPositions(newPosition, newShapeArray);
 
         for(Pos pos : newBlockPositions) {
-            if(isPartOfTetromino(pos)) continue;
+            if(this.isPartOfTetromino(pos)) continue;
             if(this.instance.getBlock(pos) == this.getGhostBlock()) continue;
             if(this.instance.getBlock(pos) != Block.AIR) return true;
         }
@@ -234,7 +234,7 @@ public class Tetromino {
     }
 
     private boolean checkCollisionAndMove(Pos newPosition, int[][] newShapeArray) {
-        if(!checkCollision(newPosition, newShapeArray)) {
+        if(!this.checkCollision(newPosition, newShapeArray)) {
             this.remove();
             this.shapeArray = Arrays.stream(newShapeArray).map(int[]::clone).toArray(int[][]::new);
             this.setPosition(newPosition);

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

@@ -3,23 +3,74 @@ 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.generator.MazeGenerator;
-import eu.mhsl.minenet.minigames.score.NoScore;
+import eu.mhsl.minenet.minigames.score.LastWinsScore;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.EntityType;
 import net.minestom.server.entity.Player;
-import net.minestom.server.item.ItemStack;
+import net.minestom.server.instance.batch.AbsoluteBlockBatch;
-import net.minestom.server.item.Material;
+import net.minestom.server.instance.block.Block;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
 
 public class Towerdefense extends StatelessGame {
+    private final Random random = new Random();
+    private final AbsoluteBlockBatch mazeBatch = new AbsoluteBlockBatch();
+    private final List<Pos> mazePath = new ArrayList<>();
+    private List<TowerdefenseRoom> instances = new ArrayList<>();
+
     public Towerdefense() {
-        super(Dimension.NETHER.key, "Towerdefense", new NoScore());
+        super(Dimension.NETHER.key, "Towerdefense", new LastWinsScore());
 
         setGenerator(new MazeGenerator());
+        this.generateMaze();
+    }
+
+    private void generateMaze() {
+        Pos position = new Pos(0, 0, 0);
+        this.addMazePosition(position, Block.GREEN_WOOL);
+
+        List<Integer> previousDirections = new ArrayList<>();
+        int direction = 1;      // 0 -> right; 1 -> straight; 2 -> left
+        for (int i = 0; i < 9; i++) {
+            for (int j = 0; j < 3; 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,1), Block.WHITE_WOOL);
+        this.addMazePosition(position.add(0,0,2), Block.RED_WOOL);
+    }
+
+    private void addMazePosition(Pos position, Block pathBlock) {
+        this.mazeBatch.setBlock(position, pathBlock);
+        this.mazePath.add(position.add(0.5,1,0.5));
+    }
+
+    public AbsoluteBlockBatch getMazeBatch() {
+        return this.mazeBatch;
+    }
+
+    public List<Pos> getMazePath() {
+        return this.mazePath;
     }
 
     @Override
     protected boolean onPlayerJoin(Player p) {
-        p.getInventory().setItemStack(1, ItemStack.of(Material.ARMOR_STAND));
+        TowerdefenseRoom newRoom = new TowerdefenseRoom(p, this);
+        this.instances.add(newRoom);
+        p.setInstance(newRoom);
+        newRoom.startWave(List.of(EntityType.ENDERMAN, EntityType.BLAZE, EntityType.PLAYER, EntityType.HORSE, EntityType.ARMOR_STAND, EntityType.SKELETON));
         return false;
     }
-
-    
 }

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

@@ -0,0 +1,58 @@
+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.generator.MazeGenerator;
+import eu.mhsl.minenet.minigames.util.BatchUtil;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.entity.*;
+import net.minestom.server.entity.attribute.Attribute;
+import net.minestom.server.instance.InstanceContainer;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+import net.minestom.server.timer.TaskSchedule;
+
+import java.util.List;
+import java.util.UUID;
+
+public class TowerdefenseRoom extends InstanceContainer {
+    private final Player player;
+    private final Towerdefense game;
+
+    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.player.getInventory().setItemStack(0, ItemStack.of(Material.ARMOR_STAND));
+
+        setGenerator(new MazeGenerator());
+        BatchUtil.loadAndApplyBatch(this.game.getMazeBatch(), this, () -> {});
+    }
+
+    public void startWave(List<EntityType> entities) {
+        int counter = 0;
+        for(EntityType entityType : entities) {
+            MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+                this.addEntity(new EntityCreature(entityType));
+                return TaskSchedule.stop();
+            }, TaskSchedule.millis(800L*counter));
+            counter++;
+        }
+    }
+
+    private void addEntity(EntityCreature entity) {
+        entity.setInstance(this, this.game.getMazePath().getFirst());
+        entity.getAttribute(Attribute.MOVEMENT_SPEED).setBaseValue(0.15);
+        entity.getNavigator().setPathTo(this.game.getMazePath().get(1), 0.7, () -> changeEntityGoal(entity, 1));
+    }
+
+    private void changeEntityGoal(EntityCreature entity, int positionIndex) {
+        if(positionIndex == this.game.getMazePath().size()-1) {
+            return;
+        }
+        entity.getNavigator().setPathTo(this.game.getMazePath().get(positionIndex+1), 0.7, () -> changeEntityGoal(entity, positionIndex+1));
+    }
+
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/turtleGame/TurtleGame.java

@@ -0,0 +1,265 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.turtleGame;
+
+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.turtleGame.gameObjects.Turtle;
+import eu.mhsl.minenet.minigames.score.PointsWinScore;
+import net.kyori.adventure.sound.Sound;
+import net.kyori.adventure.text.Component;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.kyori.adventure.text.format.TextDecoration;
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Pos;
+import net.minestom.server.entity.*;
+import net.minestom.server.entity.metadata.other.FallingBlockMeta;
+import net.minestom.server.event.player.PlayerStartSneakingEvent;
+import net.minestom.server.event.player.PlayerStopSneakingEvent;
+import net.minestom.server.event.player.PlayerTickEvent;
+import net.minestom.server.instance.block.Block;
+import net.minestom.server.item.ItemStack;
+import net.minestom.server.item.Material;
+import net.minestom.server.network.packet.server.play.ParticlePacket;
+import net.minestom.server.particle.Particle;
+import net.minestom.server.sound.SoundEvent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+class TurtleGame extends StatelessGame {
+    private final int radius;
+    private final Map<Player, Turtle> turtlePlayerMap = new WeakHashMap<>();
+    private final ArrayList<Entity> snacks = new ArrayList<>();
+    private final ArrayList<Entity> bombs = new ArrayList<>();
+    private final Block snackBlock = Block.SUNFLOWER.withProperty("half", "upper");
+    private final double startSpeed;
+
+    public TurtleGame(int radius, int startSpeed) {
+        super(Dimension.OVERWORLD.key, "Turtle Game", new PointsWinScore());
+        this.radius = radius;
+        this.startSpeed = startSpeed;
+
+        this.eventNode()
+            .addListener(PlayerTickEvent.class, this::onPlayerTick)
+            .addListener(PlayerStartSneakingEvent.class, this::onPlayerStartSneak)
+            .addListener(PlayerStopSneakingEvent.class, this::onPlayerStopSneak);
+    }
+
+    @Override
+    protected void onLoad(@NotNull CompletableFuture<Void> callback) {
+        this.generatePlatform();
+    }
+
+    private void generatePlatform() {
+        for(int x = -this.radius - 1; x <= this.radius + 1; x++) {
+            for(int z = -this.radius - 1; z <= this.radius + 1; z++) {
+                double distance = new Pos(x, 0, z).distance(new Pos(0, 0, 0));
+                if(distance <= this.radius) {
+                    boolean isEdge = this.radius - 1 < distance;
+                    this.setBlock(x, 0, z, Block.SAND);
+                    this.setBlock(x, 1, z, isEdge ? Block.STONE : Block.AIR);
+                    this.setBlock(x, 2, z, isEdge ? Block.STONE_SLAB : Block.AIR);
+                } else {
+                    this.setBlock(x, 0, z, Block.AIR);
+                }
+            }
+        }
+    }
+
+    private void onPlayerStartSneak(@NotNull PlayerStartSneakingEvent event) {
+        Player p = event.getPlayer();
+        this.turtlePlayerMap.get(p).boostSpeed();
+    }
+
+    private void onPlayerStopSneak(@NotNull PlayerStopSneakingEvent event) {
+        Player p = event.getPlayer();
+        this.turtlePlayerMap.get(p).cancelBoost();
+    }
+
+    protected void onPlayerTick(@NotNull PlayerTickEvent event) {
+        Player p = event.getPlayer();
+        if(p.getGameMode() == GameMode.SPECTATOR) return;
+        Turtle turtle = this.turtlePlayerMap.get(p);
+        turtle.adaptView();
+        if(this.isRunning()) {
+            turtle.move();
+            this.snacks.stream()
+                .filter(turtle::checkCollisionWithEntity)
+                .toList()
+                .forEach(snack -> {
+                    this.eat(p, snack);
+                    this.generateNewSnack();
+                    if(this.turtlePlayerMap.get(p).getScore() % 5 == 0) {
+                        this.generateNewBomb();
+                        this.addSpeed(0.4, p);
+                    }
+                });
+            this.bombs.stream()
+                .filter(turtle::checkCollisionWithEntity)
+                .toList()
+                .forEach(bomb -> {
+                    this.explode(p, bomb);
+                    this.generateNewBombs(2);
+                    this.addGlobalSpeed(0.3);
+                });
+        }
+    }
+
+    protected void addSpeed(double amount, Player p) {
+        this.turtlePlayerMap.get(p).addSpeed(amount);
+    }
+
+    protected void addGlobalSpeed(double amount) {
+        this.turtlePlayerMap.values().forEach(turtle -> turtle.addSpeed(amount));
+    }
+
+    protected void eat(Player p, Entity snack) {
+        p.playSound(Sound.sound(SoundEvent.ENTITY_GENERIC_EAT, Sound.Source.MASTER, 1f, 1f), snack.getPosition());
+        Material snackMaterial = this.snackBlock.registry().material();
+        if(snackMaterial == null) snackMaterial = Material.DIRT;
+        p.sendPacket(new ParticlePacket(Particle.ITEM.withItem(ItemStack.of(snackMaterial)), p.getPosition(), new Pos(0.5, 0.5, 0.5), 0, 8));
+        this.snacks.remove(snack);
+        snack.remove();
+        this.turtlePlayerMap.get(p).increaseScore();
+        this.turtlePlayerMap.get(p).increaseBoostChargeLevel(0.04f);
+    }
+
+    protected void explode(Player p, Entity bomb) {
+        this.letPlayerLoose(p);
+        p.playSound(Sound.sound(SoundEvent.ENTITY_GENERIC_EXPLODE, Sound.Source.MASTER, 2f, 1f), bomb.getPosition());
+        p.playSound(Sound.sound(SoundEvent.ENTITY_GENERIC_EXPLODE, Sound.Source.MASTER, 2f, 1f), bomb.getPosition());
+        p.sendPacket(new ParticlePacket(Particle.EXPLOSION, p.getPosition(), new Pos(0.5, 0.5, 0.5), 0, 8));
+        if(this.getLeftPlayers().size() == 1) this.setTimeLimit(10);
+        this.bombs.remove(bomb);
+        bomb.remove();
+    }
+
+    protected void letPlayerLoose(Player p) {
+        p.setGameMode(GameMode.SPECTATOR);
+        p.setFlying(true);
+        this.turtlePlayerMap.get(p).destroy();
+        this.getScore().insertResult(p, this.turtlePlayerMap.get(p).getScore());
+    }
+
+    protected List<Player> getLeftPlayers() {
+        return this.turtlePlayerMap.keySet().stream()
+            .filter(player -> !this.getScore().hasResult(player))
+            .toList();
+    }
+
+    @Override
+    protected boolean onPlayerJoin(Player p) {
+        this.turtlePlayerMap.putIfAbsent(p, new Turtle(p, this.startSpeed));
+        p.setLevel(this.turtlePlayerMap.get(p).getScore());
+
+        Turtle turtle = this.turtlePlayerMap.get(p);
+        MinecraftServer.getSchedulerManager().scheduleNextTick(turtle::spawnTurtle);
+        return super.onPlayerJoin(p);
+    }
+
+    @Override
+    protected void onPlayerLeave(Player p) {
+        Turtle turtle = this.turtlePlayerMap.get(p);
+        turtle.remove();
+    }
+
+    @Override
+    public Pos getSpawn() {
+        double theta = this.rnd.nextDouble() * 2 * Math.PI;
+
+        double spawnRadius = this.radius - 4;
+        double x = spawnRadius * Math.cos(theta);
+        double z = spawnRadius * Math.sin(theta);
+
+        return new Pos(x, 1, z).withLookAt(new Pos(0, 0, 0));
+    }
+
+    private void generateNewSnacks(int count) {
+        for (int i = 0; i < count; i++) {
+            this.generateNewSnack();
+        }
+    }
+
+    private void generateNewSnack() {
+        Entity snack = new Entity(EntityType.FALLING_BLOCK);
+        FallingBlockMeta meta = (FallingBlockMeta) snack.getEntityMeta();
+        meta.setBlock(this.snackBlock.withProperty("half", "upper"));
+        meta.setCustomName(Component.text("Snack").color(NamedTextColor.WHITE));
+        meta.setCustomNameVisible(true);
+        snack.setInstance(this);
+        Pos spawnPosition = this.newSpawnPosition(snack);
+        if(spawnPosition == null) {
+            snack.remove();
+            return;
+        }
+        snack.teleport(spawnPosition);
+        this.snacks.add(snack);
+    }
+
+    private void generateNewBombs(int count) {
+        for (int i = 0; i < count; i++) {
+            this.generateNewBomb();
+        }
+    }
+
+    private void generateNewBomb() {
+        Entity bomb = new Entity(EntityType.FALLING_BLOCK);
+        FallingBlockMeta meta = (FallingBlockMeta) bomb.getEntityMeta();
+        meta.setBlock(Block.TNT);
+        meta.setCustomName(Component.text("Bomb").color(NamedTextColor.RED).decorate(TextDecoration.BOLD));
+        meta.setCustomNameVisible(true);
+        bomb.setInstance(this);
+        Pos spawnPosition = this.newSpawnPosition(bomb, false);
+        if(spawnPosition == null) {
+            bomb.remove();
+            return;
+        }
+        bomb.teleport(spawnPosition);
+        this.bombs.add(bomb);
+    }
+
+    @Nullable
+    private Pos newSpawnPosition(Entity entity) {
+        return this.newSpawnPosition(entity, true);
+    }
+
+    @Nullable
+    private Pos newSpawnPosition(Entity entity, boolean nearPlayers) {
+        Pos spawnPosition;
+        int counter = 0;
+        boolean isInRadius, collides;
+        do {
+            if(counter > 200) {
+                return null;
+            }
+            int x = this.rnd.nextInt(-this.radius+2, this.radius-2);
+            int z = this.rnd.nextInt(-this.radius+2, this.radius-2);
+            spawnPosition = new Pos(x, 1, z).add(0.5, 0, 0.5);
+            Pos checkPosition = spawnPosition;
+            isInRadius = checkPosition.distance(0, 1, 0) < this.radius-2;
+            collides = this.getEntities().stream()
+                .filter(e -> !e.equals(entity))
+                .anyMatch(e -> entity.getBoundingBox().intersectBox(e.getPosition().sub(checkPosition), e.getBoundingBox()));
+            if(!collides && !nearPlayers) collides = this.turtlePlayerMap.values().stream()
+                    .filter(turtle -> !turtle.equals(entity))
+                    .anyMatch(turtle -> entity.getBoundingBox()
+                            .growSymmetrically(turtle.getBombBorder(), 1, turtle.getBombBorder())
+                            .intersectBox(turtle.getPosition().sub(checkPosition), turtle.getBoundingBox()));
+            counter++;
+        } while (!isInRadius || collides);
+        return spawnPosition;
+    }
+
+    @Override
+    protected void onStart() {
+        this.generateNewSnacks((int) Math.ceil(this.turtlePlayerMap.size() * 1.5));
+        this.generateNewBombs((int) Math.ceil(this.snacks.size() * 0.5));
+        this.turtlePlayerMap.values().forEach(Turtle::startBoostRefill);
+    }
+
+    @Override
+    protected void onStop() {
+        this.getLeftPlayers().forEach(this::letPlayerLoose);
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/turtleGame/TurtleGameFactory.java

@@ -0,0 +1,42 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.turtleGame;
+
+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 TurtleGameFactory implements GameFactory {
+
+    @Override
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_TurtleGame#name");
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_TurtleGame#description");
+    }
+
+    @Override
+    public ConfigManager configuration() {
+        return new ConfigManager()
+            .addOption(new NumericOption("radius", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#radius"), 10, 20, 30, 40))
+            .addOption(new NumericOption("startSpeed", Material.LEATHER_BOOTS, TranslatedComponent.byId("game_TurtleGame#startSpeed"), 2, 3, 4, 6, 8));
+    }
+
+    @Override
+    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
+        return new TurtleGame(configuration.get("radius").getAsInt(), configuration.get("startSpeed").getAsInt()).setParent(parent);
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.TURTLE_EGG;
+    }
+}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/turtleGame/gameObjects/Turtle.java

@@ -0,0 +1,112 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.turtleGame.gameObjects;
+
+import net.minestom.server.MinecraftServer;
+import net.minestom.server.coordinate.Vec;
+import net.minestom.server.entity.Entity;
+import net.minestom.server.entity.EntityCreature;
+import net.minestom.server.entity.EntityType;
+import net.minestom.server.entity.Player;
+import net.minestom.server.entity.attribute.Attribute;
+import net.minestom.server.timer.Task;
+import net.minestom.server.timer.TaskSchedule;
+
+public class Turtle extends EntityCreature {
+    private final Player player;
+    private int score = 0;
+    private double speed;
+    private double boostSpeedMultiplier = 1;
+    private float boostChargeLevel = 0f;
+    private Task boostTask;
+    private Task boostRefillTask;
+
+    public Turtle(Player player, double speed) {
+        super(EntityType.TURTLE);
+        this.player = player;
+        this.speed = speed;
+
+        this.getAttribute(Attribute.MOVEMENT_SPEED).setBaseValue(0.15);
+        this.getAttribute(Attribute.MAX_HEALTH).setBaseValue(1);
+        this.player.setExp(this.boostChargeLevel);
+    }
+
+    public void spawnTurtle() {
+        this.setInstance(this.player.getInstance());
+        this.teleport(this.player.getPosition());
+        this.addPassenger(this.player);
+    }
+
+    public void startBoostRefill() {
+        this.boostRefillTask = MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+            if(this.boostChargeLevel >= 1f) return;
+            this.increaseBoostChargeLevel(0.02f);
+        }, TaskSchedule.seconds(1), TaskSchedule.seconds(1));
+    }
+
+    public void destroy() {
+        this.removePassenger(this.player);
+        this.remove();
+        this.kill();
+        if(this.boostRefillTask.isAlive()) this.boostRefillTask.cancel();
+        if(this.boostTask.isAlive()) this.boostTask.cancel();
+    }
+
+    public void adaptView() {
+        this.teleport(this.getPosition().withView(this.player.getPosition().withPitch(this.getPosition().pitch())));
+        Vec lookingVector = this.player.getPosition().direction().withY(0).mul(100);
+        this.lookAt(this.getPosition().add(lookingVector.asPosition()));
+    }
+
+    public void move() {
+        this.adaptView();
+        Vec direction = this.player.getPosition().direction();
+        Vec movementVector = direction.withY(0).normalize().mul(this.speed * this.boostSpeedMultiplier);
+        this.setVelocity(movementVector);
+    }
+
+    public boolean checkCollisionWithEntity(Entity other) {
+        return this.getBoundingBox().intersectBox(other.getPosition().sub(this.getPosition()), other.getBoundingBox());
+    }
+
+    public void boostSpeed() {
+        if(this.boostChargeLevel <= 0f) return;
+        this.boostSpeedMultiplier = 3.5;
+        this.boostTask = MinecraftServer.getSchedulerManager().scheduleTask(() -> {
+            if(this.boostChargeLevel <= 0f) {
+                this.cancelBoost();
+                return;
+            }
+            this.boostChargeLevel = Math.max(0f, this.boostChargeLevel - 0.025f);
+            System.out.println(this.boostChargeLevel);
+            this.player.setExp(this.boostChargeLevel);
+        }, TaskSchedule.millis(30), TaskSchedule.millis(30));
+    }
+
+    public void cancelBoost() {
+        if(!this.boostTask.isAlive()) return;
+        this.boostTask.cancel();
+        this.boostSpeedMultiplier = 1;
+    }
+
+    public void increaseBoostChargeLevel(float amount) {
+        this.boostChargeLevel = Math.min(1f, this.boostChargeLevel + amount);
+        this.player.setExp(this.boostChargeLevel);
+    }
+
+    public void addSpeed(double amount) {
+        this.speed += amount;
+    }
+
+    public int getScore() {
+        return this.score;
+    }
+
+    public double getBombBorder() {
+        // 1 bei speed 2; 2 bei speed 4; 4 bei speed 8
+        return Math.clamp((this.speed * this.boostSpeedMultiplier) / 2, 1.5, 4);
+    }
+
+    public void increaseScore() {
+        this.score += 1;
+        this.player.setLevel(this.score);
+    }
+}

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

@@ -66,6 +66,8 @@ public class Room extends MineNetInstance implements Spawnable {
         p.getInventory().clear();
         p.setGameMode(GameMode.ADVENTURE);
         p.setInvisible(false);
+        p.setExp(0);
+        p.setLevel(0);
         rooms.add(room);
         players.put(p, room);
         MoveInstance.move(p, room);
@@ -88,29 +90,29 @@ public class Room extends MineNetInstance implements Spawnable {
     private Room(Player owner) {
         super(Dimension.THE_END.key);
         this.apiDriven = false;
-        construct();
+        this.construct();
-        setOwner(owner);
+        this.setOwner(owner);
     }
 
     protected Room() {
         super(Dimension.THE_END.key);
         this.apiDriven = true;
-        construct();
+        this.construct();
     }
 
     private void construct() {
         MinecraftServer.getInstanceManager().registerInstance(this);
-        setChunkLoader(new AnvilLoader(Resource.LOBBY_MAP.getPath()));
+        this.setChunkLoader(new AnvilLoader(Resource.LOBBY_MAP.getPath()));
 
         this.gameSelector = new GameSelector();
         this.gameSelector.setInstance(this, new Pos(0.5, 50, 19.5));
 
-        eventNode().addListener(PlayerBlockBreakEvent.class, CommonEventHandles::cancel);
+        this.eventNode().addListener(PlayerBlockBreakEvent.class, CommonEventHandles::cancel);
-        eventNode().addListener(PlayerDisconnectEvent.class, playerDisconnectEvent -> unsetRoom(playerDisconnectEvent.getPlayer()));
+        this.eventNode().addListener(PlayerDisconnectEvent.class, playerDisconnectEvent -> unsetRoom(playerDisconnectEvent.getPlayer()));
     }
 
     public Player getOwner() {
-        return owner;
+        return this.owner;
     }
 
     public void setOwner(Player newOwner) {
@@ -123,7 +125,7 @@ public class Room extends MineNetInstance implements Spawnable {
 
             if(p != this.owner) return;
 
-            getAllMembers().stream()
+            this.getAllMembers().stream()
                     .filter(player -> player != p) // exclude the current leaving owner
                     .findFirst()
                     .ifPresentOrElse(
@@ -133,8 +135,8 @@ public class Room extends MineNetInstance implements Spawnable {
 
             Room.unsetRoom(p);
 
-            new ChatMessage(Icon.ERROR).appendStatic("The room leader left!").send(getAllMembers());
+            new ChatMessage(Icon.ERROR).appendStatic("The room leader left!").send(this.getAllMembers());
-            new ChatMessage(Icon.SCIENCE).appendStatic(this.owner.getUsername()).appendStatic(" is the new Leader!").send(getAllMembers().stream().filter(player -> player != this.owner).collect(Collectors.toSet()));
+            new ChatMessage(Icon.SCIENCE).appendStatic(this.owner.getUsername()).appendStatic(" is the new Leader!").send(this.getAllMembers().stream().filter(player -> player != this.owner).collect(Collectors.toSet()));
             new ChatMessage(Icon.SUCCESS).appendStatic("You are now the leader.").send(this.owner);
         });
     }

src/main/java/eu/mhsl/minenet/minigames/world/BlockPallet.java

@@ -12,7 +12,7 @@ public enum BlockPallet {
     STONE(new Block[] {Block.CHISELED_STONE_BRICKS, Block.STONE_BRICKS, Block.POLISHED_ANDESITE, Block.POLISHED_BLACKSTONE, Block.POLISHED_DIORITE}),
     WINTER(new Block[] {Block.SNOW_BLOCK, Block.ICE, Block.PACKED_ICE, Block.BLUE_CONCRETE, Block.SEA_LANTERN}),
     STREET(new Block[] {Block.BLACK_CONCRETE_POWDER, Block.GRAY_CONCRETE_POWDER, Block.GRAVEL, Block.BLACK_CONCRETE, Block.GRAY_CONCRETE}),
-
+    FLOWER(new Block[] {Block.ORANGE_TULIP, Block.PINK_TULIP, Block.RED_TULIP, Block.WHITE_TULIP}),
     PRESSURE_PLATES(new Block[] {Block.ACACIA_PRESSURE_PLATE, Block.BIRCH_PRESSURE_PLATE, Block.CRIMSON_PRESSURE_PLATE, Block.JUNGLE_PRESSURE_PLATE, Block.OAK_PRESSURE_PLATE, Block.DARK_OAK_PRESSURE_PLATE, Block.HEAVY_WEIGHTED_PRESSURE_PLATE, Block.HEAVY_WEIGHTED_PRESSURE_PLATE, Block.POLISHED_BLACKSTONE_PRESSURE_PLATE, Block.SPRUCE_PRESSURE_PLATE, Block.STONE_PRESSURE_PLATE, Block.WARPED_PRESSURE_PLATE});
 
     final List<Block> list;

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

@@ -21,6 +21,7 @@ public class ValeGenerator extends HeightTerrainGenerator {
             .build();
 
     private Function<Integer, Double> xShiftMultiplier = multiplier -> 1d;
+    private Function<Integer, Double> xShiftOffset = z -> 0d;
 
     public ValeGenerator() {
         setCalculateHeight(this::calculateY);
@@ -32,10 +33,14 @@ public class ValeGenerator extends HeightTerrainGenerator {
     }
 
     public int getXShiftAtZ(int z) {
-        return (int) ((curves.getNoise(z) * 32 + largeCurves.getNoise(z) * 64) * xShiftMultiplier.apply(z));
+        return (int) ((curves.getNoise(z) * 32 + largeCurves.getNoise(z) * 64) * xShiftMultiplier.apply(z) + xShiftOffset.apply(z));
     }
 
     public void setXShiftMultiplier(Function<Integer, Double> xShiftMultiplier) {
         this.xShiftMultiplier = xShiftMultiplier;
     }
+
+    public void setXShiftOffset(Function<Integer, Double> xShiftOffset) {
+        this.xShiftOffset = xShiftOffset;
+    }
 }

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

@@ -130,3 +130,21 @@ 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!
+;;
+ns:game_Sumo#;;
+name;Sumo;Sumo
+lives;Lives;Leben
+description;Knock your enemies off and stay on top!;Versuche deinen Gegner von der Plattform zu schubsen!
+;;
+ns:game_Highground#;;
+name;Highground;Hochburg
+description;Stay on the high ground to win!;Bleibe solange wie möglich auf der Hochburg, um zu gewinnen!
+;;
+ns:game_Fastbridge#;;
+name;Fastbridge;Fastbridge
+description;Speedbridge to the other platform. The first one there wins!;Baue dich so schnell wie möglich zur anderen Plattform. Wer zuerst dort ist, gewinnt!
+;;
+ns:game_TurtleGame#;;
+name;Turtle Game;Turtle Game
+description;Eat snacks and dodge bombs to get the highest score!;Esse Snacks und weiche Bomben aus, um den höchsten Score zu erreichen!
+startSpeed;Start Speed;Startgeschwindigkeit