added turtle game to pve

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

@@ -2,7 +2,6 @@ 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.blockBreakRace.BlockBreakRaceFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.bowSpleef.BowSpleefFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.elytraRace.ElytraRaceFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.backrooms.BackroomsFactory;
@@ -13,7 +12,6 @@ import eu.mhsl.minenet.minigames.instance.game.stateless.types.fastbridge.Fastbr
 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.spaceSnake.SpaceSnakeFactory;
 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;
@@ -21,6 +19,7 @@ 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),
@@ -35,14 +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),
     SUMO(new SumoFactory(), GameType.PVP),
     HIGHGROUND(new HighGroundFactory(), GameType.PVP),
-    FASTBRIDGE(new FastbridgeFactory(), GameType.OTHER),
-    BLOCKBREAKRACE(new BlockBreakRaceFactory(), GameType.OTHER),
-    SPACESNAKE(new SpaceSnakeFactory(), GameType.PVP);
+    FASTBRIDGE(new FastbridgeFactory(), GameType.OTHER);
 
     private final GameFactory factory;
     private final GameType type;

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/blockBreakRace/BlockBreakRace.java

@@ -1,79 +0,0 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.blockBreakRace;
-
-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.PlayerBlockBreakEvent;
-import net.minestom.server.event.player.PlayerMoveEvent;
-import net.minestom.server.inventory.PlayerInventory;
-import net.minestom.server.item.ItemStack;
-import net.minestom.server.item.Material;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.List;
-
-public class BlockBreakRace extends StatelessGame {
-    private int spawnCount = 0;
-    private final int height;
-
-    public BlockBreakRace(int height) {
-        super(Dimension.OVERWORLD.key, "blockBreakRace", new FirstWinsScore());
-        this.height = height;
-        this.setGenerator(new BlockBreakRaceGenerator(height));
-    }
-
-    @Override
-    protected boolean onPlayerJoin(Player p) {
-        PlayerInventory inv = p.getInventory();
-        inv.addItemStack(ItemStack.of(Material.DIAMOND_PICKAXE));
-        inv.addItemStack(ItemStack.of(Material.DIAMOND_AXE));
-        inv.addItemStack(ItemStack.of(Material.DIAMOND_SHOVEL));
-        return super.onPlayerJoin(p);
-    }
-
-    @Override
-    protected void onStart() {
-        this.getPlayers().forEach(player -> player.setGameMode(GameMode.SURVIVAL));
-    }
-
-    @Override
-    protected void onBlockBreak(@NotNull PlayerBlockBreakEvent event) {
-        List<Material> allowedMaterials = List.of(Material.STONE, Material.OAK_PLANKS, Material.DIRT);
-        if(!allowedMaterials.contains(event.getBlock().registry().material())) event.setCancelled(true);
-        if(this.isBeforeBeginning) event.setCancelled(true);
-    }
-
-    @Override
-    protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
-        if(this.isBeforeBeginning) return;
-        if(playerMoveEvent.getNewPosition().y() < BlockBreakRaceGenerator.BOTTOM_Y) {
-            Player player = playerMoveEvent.getPlayer();
-            this.getScore().insertResult(player);
-            player.setGameMode(GameMode.SPECTATOR);
-            player.getInventory().clear();
-        }
-    }
-
-    @Override
-    public Pos getSpawn() {
-        int idx = this.spawnCount++;
-
-        int cols = BlockBreakRaceGenerator.ROW_OFFSETS_X.length;
-        int rows = BlockBreakRaceGenerator.ROW_OFFSETS_Z.length;
-        int perChunk = cols * rows;
-        int zChunk = idx / perChunk;
-
-        int gridIndex = idx % perChunk;
-        int xIndex = gridIndex % cols;
-        int zIndex = gridIndex / cols;
-
-        int localX = BlockBreakRaceGenerator.ROW_OFFSETS_X[xIndex];
-        int localZ = BlockBreakRaceGenerator.ROW_OFFSETS_Z[zIndex];
-
-        int absZ = (zChunk * 16) + localZ;
-        return new Pos(localX, BlockBreakRaceGenerator.BOTTOM_Y + this.height + 1, absZ).add(0.5);
-    }
-}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/blockBreakRace/BlockBreakRaceGenerator.java

@@ -1,67 +0,0 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.blockBreakRace;
-
-import eu.mhsl.minenet.minigames.world.generator.featureEnriched.ValeGenerator;
-import eu.mhsl.minenet.minigames.world.generator.terrain.BaseGenerator;
-import net.minestom.server.coordinate.Pos;
-import net.minestom.server.instance.block.Block;
-import net.minestom.server.instance.generator.GenerationUnit;
-
-import java.util.Random;
-import java.util.concurrent.ThreadLocalRandom;
-
-public class BlockBreakRaceGenerator extends BaseGenerator {
-    public static final int BOTTOM_Y = 50;
-    public final int TOP_Y;
-    public static final int[] ROW_OFFSETS_X = {4, 8, 12};
-    public static final int[] ROW_OFFSETS_Z = {4, 8, 12};
-
-    private static final Block[] FILL_BLOCKS = {
-        Block.STONE,
-        Block.DIRT,
-        Block.OAK_PLANKS
-    };
-
-    private final Random random = ThreadLocalRandom.current();
-
-    public BlockBreakRaceGenerator(int height) {
-        this.TOP_Y = BOTTOM_Y + height;
-        ValeGenerator vale = new ValeGenerator();
-        vale.setXShiftMultiplier(i -> 0.5d);
-        vale.setHeightNoiseMultiplier(i -> 2);
-        vale.setXShiftOffset(i -> 40d);
-        this.addMixIn(vale);
-
-        this.addMixIn(unit -> {
-            if(unit.absoluteStart().chunkX() != 0) return;
-
-            for (int localX : ROW_OFFSETS_X) {
-                for (int localZ : ROW_OFFSETS_Z) {
-                    final int absZ = unit.absoluteStart().blockZ() + localZ;
-                    this.placeTube(unit, localX, absZ);
-                }
-            }
-        });
-    }
-
-    private void placeTube(GenerationUnit unit, int x, int z) {
-        for (int y = BOTTOM_Y; y < this.TOP_Y; y++) {
-            Block fill = FILL_BLOCKS[this.random.nextInt(FILL_BLOCKS.length)];
-            unit.modifier().fill(
-                new Pos(x, y, z),
-                new Pos(x, y, z).add(1),
-                fill
-            );
-        }
-
-        for (int dx = -1; dx <= 1; dx++) {
-            for (int dz = -1; dz <= 1; dz++) {
-                if (dx == 0 && dz == 0) continue; // Zentrum überspringen
-                unit.modifier().fill(
-                    new Pos(x + dx, BOTTOM_Y, z + dz),
-                    new Pos(x + dx, this.TOP_Y + 3, z + dz).add(1),
-                    Block.BARRIER
-                );
-            }
-        }
-    }
-}

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

@@ -3,8 +3,6 @@ package eu.mhsl.minenet.minigames.instance.game.stateless.types.bowSpleef;
 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.game.stateless.config.restriction.RestrictionHandler;
-import eu.mhsl.minenet.minigames.instance.game.stateless.config.restriction.common.MinimalPlayeramountGameRestriction;
 import eu.mhsl.minenet.minigames.instance.room.Room;
 import eu.mhsl.minenet.minigames.message.component.TranslatedComponent;
 import net.minestom.server.item.Material;
@@ -31,10 +29,4 @@ public class BowSpleefFactory implements GameFactory {
     public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
         return new BowSpleef().setParent(parent);
     }
-
-    @Override
-    public RestrictionHandler globalRestrictions() {
-        return new RestrictionHandler()
-                .addRestriction(new MinimalPlayeramountGameRestriction(2));
-    }
 }

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

@@ -8,7 +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.GameMode;
+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;
@@ -69,9 +69,7 @@ class Deathcube extends StatelessGame {
             playerMoveEvent.setCancelled(true);
             return;
         }
-        if(playerMoveEvent.getNewPosition().y() <= height) return;
-        getScore().insertResult(playerMoveEvent.getPlayer());
-        playerMoveEvent.getPlayer().setGameMode(GameMode.SPECTATOR);
+        if(playerMoveEvent.getNewPosition().y() > height) getScore().insertResult(playerMoveEvent.getPlayer());
     }
 
     @Override

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

@@ -33,7 +33,6 @@ import org.jetbrains.annotations.NotNull;
 import java.time.Duration;
 import java.util.HashMap;
 import java.util.Map;
-import java.util.Random;
 import java.util.concurrent.CompletableFuture;
 
 
@@ -184,8 +183,7 @@ public class ElytraRace extends StatelessGame {
     }
 
     private Point getRingPositionAtZ(int z) {
-        Random random = new Random(this.hashCode() + z);
-        return new Pos(vale.getXShiftAtZ(z), -45 + random.nextInt(-5, 15), z);
+        return new Pos(vale.getXShiftAtZ(z), -45, z);
     }
 
     private CompletableFuture<Void> generateRing(int zPos) {

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

@@ -5,8 +5,6 @@ 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.game.stateless.config.restriction.RestrictionHandler;
-import eu.mhsl.minenet.minigames.instance.game.stateless.config.restriction.common.MinimalPlayeramountGameRestriction;
 import eu.mhsl.minenet.minigames.instance.room.Room;
 import eu.mhsl.minenet.minigames.message.component.TranslatedComponent;
 import net.minestom.server.item.Material;
@@ -40,10 +38,4 @@ public class HighGroundFactory implements GameFactory {
     public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
         return new HighGround(configuration.get("radius").getAsInt(), configuration.get("seconds").getAsInt()).setParent(parent);
     }
-
-    @Override
-    public RestrictionHandler globalRestrictions() {
-        return new RestrictionHandler()
-                .addRestriction(new MinimalPlayeramountGameRestriction(2));
-    }
 }

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/spaceSnake/SpaceSnake.java

@@ -1,182 +0,0 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.spaceSnake;
-
-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.MaterialUtil;
-import io.github.togar2.pvp.events.FinalAttackEvent;
-import io.github.togar2.pvp.events.PrepareAttackEvent;
-import io.github.togar2.pvp.feature.CombatFeatures;
-import net.kyori.adventure.sound.Sound;
-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.entity.EntityTickEvent;
-import net.minestom.server.event.player.PlayerBlockPlaceEvent;
-import net.minestom.server.event.player.PlayerMoveEvent;
-import net.minestom.server.instance.WorldBorder;
-import net.minestom.server.instance.block.Block;
-import net.minestom.server.inventory.PlayerInventory;
-import net.minestom.server.item.ItemStack;
-import net.minestom.server.item.Material;
-import net.minestom.server.sound.SoundEvent;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
-import java.util.function.Supplier;
-
-public class SpaceSnake extends StatelessGame {
-    record PlayState(AtomicInteger length, Queue<Pos> blocks, Material blockType, Pos spawn) {
-        public void cutToLength(Consumer<Pos> removed) {
-            while (this.blocks.size() > this.length.get()) {
-                removed.accept(this.blocks.poll());
-            }
-        }
-    }
-
-    private final Map<Player, PlayState> playerStates = new WeakHashMap<>();
-    private int mapSize;
-    private final Supplier<Integer> posInBoundsW = () -> this.rnd.nextInt(-this.mapSize/2, this.mapSize/2);
-    private final Supplier<Integer> posInBoundsH = () -> this.rnd.nextInt(-60, 300);
-
-    public SpaceSnake(int mapSize, int powerUpCount) {
-        super(Dimension.THE_END.key, "spaceSnake", new PointsWinScore());
-        this.mapSize = mapSize;
-        this.setWorldBorder(new WorldBorder(this.mapSize, 0, 0, 0, 0));
-
-        for (int i = 0; i < powerUpCount; i++) {
-            this.spawnPowerUp();
-        }
-
-        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 onStart() {
-        this.getPlayers().forEach(player -> {
-            player.setGameMode(GameMode.SURVIVAL);
-            this.updateInv(player);
-            player.setHeldItemSlot((byte) 1);
-        });
-    }
-
-    @Override
-    protected void onStop() {
-        this.getPlayers().forEach(player -> this.getScore().insertResult(player, this.playerStates.get(player).length.get()));
-    }
-
-    @Override
-    protected boolean onPlayerJoin(Player p) {
-        Pos spawn = new Pos(this.posInBoundsW.get(), -60, this.posInBoundsW.get());
-        PlayState state = new PlayState(
-            new AtomicInteger(3),
-            new ArrayDeque<>(List.of(spawn)),
-            MaterialUtil.getRandomFullBlock(material -> !material.equals(Material.DIAMOND_BLOCK)),
-            spawn
-        );
-        this.playerStates.put(p, state);
-        this.setBlock(spawn, state.blockType.block());
-        MinecraftServer.getSchedulerManager().scheduleNextTick(
-            () -> p.teleport(this.getSaveSpawn(spawn))
-        );
-        return super.onPlayerJoin(p);
-    }
-
-    @Override
-    protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
-        PlayState state = this.playerStates.get(playerMoveEvent.getPlayer());
-        if(this.isBeforeBeginning) {
-            boolean falling = state.blocks.stream().anyMatch(pos -> pos.y() > playerMoveEvent.getNewPosition().y());
-            if(falling) playerMoveEvent.getPlayer().teleport(this.getSaveSpawn(state.spawn));
-            return;
-        }
-
-        if(playerMoveEvent.getNewPosition().y() < -64) {
-            this.getScore().insertResult(playerMoveEvent.getPlayer(), state.length.get());
-            playerMoveEvent.getPlayer().teleport(this.getSpawn());
-            playerMoveEvent.getPlayer().setGameMode(GameMode.SPECTATOR);
-            long livingPlayers = this.getPlayers().stream()
-                .filter(p -> this.getScore().hasResult(p))
-                .count();
-            if(livingPlayers == 1) this.setTimeLimit(10);
-            if(livingPlayers == 0) this.stop();
-        }
-    }
-
-    @Override
-    protected void onBlockPlace(@NotNull PlayerBlockPlaceEvent playerBlockPlaceEvent) {
-        if(this.isBeforeBeginning) {
-            playerBlockPlaceEvent.setCancelled(true);
-            return;
-        }
-
-        PlayState state = this.playerStates.get(playerBlockPlaceEvent.getPlayer());
-        state.blocks.add(playerBlockPlaceEvent.getBlockPosition().asVec().asPosition());
-        state.cutToLength(pos -> this.setBlock(pos, Block.AIR));
-
-        MinecraftServer.getSchedulerManager().scheduleNextTick(() -> this.updateInv(playerBlockPlaceEvent.getPlayer()));
-        playerBlockPlaceEvent.getPlayer().setLevel(state.length.get());
-    }
-
-    private Pos getSaveSpawn(Pos blockPos) {
-        return blockPos.add(0.5).withY((y) -> y + 2);
-    }
-
-    private void updateInv(Player player) {
-        PlayerInventory inventory = player.getInventory();
-        inventory.clear();
-        inventory.addItemStack(ItemStack.of(Material.STICK, 1).with(builder -> builder.glowing(true)));
-        inventory.addItemStack(ItemStack.of(this.playerStates.get(player).blockType, 64));
-    }
-
-    private void spawnPowerUp() {
-        Pos spawnPos = new Pos(this.posInBoundsW.get(), this.posInBoundsH.get(), this.posInBoundsW.get());
-        Entity display = new Entity(EntityType.FALLING_BLOCK);
-        ((FallingBlockMeta) display.getEntityMeta()).setBlock(Block.DIAMOND_BLOCK);
-        display.setGlowing(true);
-        display.setNoGravity(true);
-        display.setInstance(this, spawnPos);
-
-        display.eventNode().addListener(EntityTickEvent.class, onTick -> {
-            Player player = this.getPlayers().stream()
-                .filter(p -> !this.getScore().hasResult(p))
-                .filter(p -> p.getBoundingBox()
-                    .grow(1, 1, 1)
-                    .intersectBox(display.getPosition().sub(p.getPosition()), display.getBoundingBox())
-                )
-                .findAny()
-                .orElse(null);
-            if(player == null) return;
-
-            this.spawnPowerUp();
-            display.remove();
-            this.onPowerup(player);
-        });
-    }
-
-    private void onPowerup(Player player) {
-        PlayState state = this.playerStates.get(player);
-        state.length.incrementAndGet();
-        player.setLevel(player.getLevel() + 1);
-        player.playSound(Sound.sound(SoundEvent.ENTITY_EXPERIENCE_ORB_PICKUP, Sound.Source.PLAYER, 1f, 1f));
-    }
-}

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/spaceSnake/SpaceSnakeFactory.java

@@ -1,41 +0,0 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.spaceSnake;
-
-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 SpaceSnakeFactory implements GameFactory {
-    @Override
-    public TranslatedComponent name() {
-        return TranslatedComponent.byId("game_SpaceSnake#name");
-    }
-
-    @Override
-    public ConfigManager configuration() {
-        return new ConfigManager()
-            .addOption(new NumericOption("width", Material.HEART_OF_THE_SEA, TranslatedComponent.byId("optionCommon#width"), 20, 30, 40, 50, 60, 70, 80))
-            .addOption(new NumericOption("powerUpCount", Material.DIAMOND, TranslatedComponent.byId("game_SpaceSnake#powerUpCount"), 50, 100, 200, 300));
-    }
-
-    @Override
-    public Material symbol() {
-        return Material.GREEN_CONCRETE_POWDER;
-    }
-
-    @Override
-    public TranslatedComponent description() {
-        return TranslatedComponent.byId("game_SpaceSnake#description");
-    }
-
-    @Override
-    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
-        return new SpaceSnake(configuration.get("width").getAsInt(), configuration.get("powerUpCount").getAsInt()).setParent(parent);
-    }
-}

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

@@ -9,7 +9,6 @@ import eu.mhsl.minenet.minigames.world.BlockPallet;
 import eu.mhsl.minenet.minigames.world.generator.terrain.CircularPlateTerrainGenerator;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.GameMode;
-import net.minestom.server.event.player.PlayerBlockBreakEvent;
 import net.minestom.server.event.player.PlayerMoveEvent;
 import net.minestom.server.event.player.PlayerStartDiggingEvent;
 import net.minestom.server.instance.batch.AbsoluteBlockBatch;
@@ -78,15 +77,6 @@ public class Spleef extends StatelessGame {
         }
     }
 
-    @Override
-    protected void onBlockBreak(@NotNull PlayerBlockBreakEvent event) {
-        if(!isRunning) {
-            event.setCancelled(true);
-            return;
-        }
-        setBlock(event.getBlockPosition(), Block.AIR);
-    }
-
     private void destroyBlock(PlayerStartDiggingEvent event) {
         if(!isRunning) return;
         setBlock(event.getBlockPosition(), Block.AIR);

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

@@ -28,7 +28,7 @@ public class StickFightFactory implements GameFactory {
     @Override
     public ConfigManager configuration() {
         return new ConfigManager()
-                .addOption(new NumericOption("length", Material.SANDSTONE, TranslatedComponent.byId("optionCommon#length"), 7, 10, 13, 16, 19));
+                .addOption(new NumericOption("length", Material.SANDSTONE, TranslatedComponent.byId("optionCommon#length"), 5, 7, 9, 11));
     }
 
     @Override
@@ -40,7 +40,7 @@ public class StickFightFactory implements GameFactory {
 
     @Override
     public Game manufacture(Room parent, Map<String, Option<?>> configuration) {
-        return new Stickfight(configuration.get("length").getAsInt()).setParent(parent);
+        return new Stickfight().setParent(parent);
     }
 
     @Override

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

@@ -2,7 +2,7 @@ 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.LowestPointsWinScore;
+import eu.mhsl.minenet.minigames.score.LastWinsScore;
 import eu.mhsl.minenet.minigames.world.generator.terrain.CircularPlateTerrainGenerator;
 import io.github.togar2.pvp.events.FinalAttackEvent;
 import io.github.togar2.pvp.feature.CombatFeatures;
@@ -13,19 +13,15 @@ import net.minestom.server.instance.block.Block;
 import org.jetbrains.annotations.NotNull;
 
 import java.util.List;
-import java.util.Map;
 import java.util.WeakHashMap;
 import java.util.concurrent.CompletableFuture;
 
 public class Stickfight extends StatelessGame {
-    private final double radius;
+    private final double radius = 20;
     private final WeakHashMap<Player, Pos> spawnPoints = new WeakHashMap<>();
-    private final Map<Player, Integer> scoreMap = new WeakHashMap<>();
-    private boolean countdownStarted = false;
 
-    public Stickfight(int length) {
-        super(Dimension.OVERWORLD.key, "Stickfight", new LowestPointsWinScore());
-        this.radius = length;
+    public Stickfight() {
+        super(Dimension.OVERWORLD.key, "Stickfight", new LastWinsScore());
 
         eventNode().addChild(
             CombatFeatures.empty()
@@ -36,7 +32,6 @@ public class Stickfight extends StatelessGame {
         );
 
         eventNode().addListener(FinalAttackEvent.class, finalAttackEvent -> {
-            if(isBeforeBeginning) finalAttackEvent.setCancelled(true);
             finalAttackEvent.setBaseDamage(0);
             ((Player) finalAttackEvent.getTarget()).setHealth(20);
         });
@@ -46,26 +41,14 @@ public class Stickfight extends StatelessGame {
 
     @Override
     protected void onLoad(@NotNull CompletableFuture<Void> callback) {
-        this.replaceCircle(Block.SANDSTONE);
-    }
-
-    private void replaceCircle(Block block) {
-        int radius = 8;
-        for (int x = -radius; x <= radius; x++) {
-            for (int z = -radius; z <= radius; z++) {
-                Pos blockPosition = this.getSpawn().add(x, -1, z);
-                if(blockPosition.distance(this.getSpawn().sub(0, 1, 0)) <= radius) this.setBlock(blockPosition, block);
-            }
-        }
+        setBlock(0, 50, 0, Block.DIAMOND_BLOCK);
     }
 
     @Override
     protected void start() {
         List<Player> players = getPlayers().stream().toList();
         int numPlayers = players.size();
-        this.countdownStarted = true;
 
-        this.replaceCircle(Block.AIR);
         for (int i = 0; i < numPlayers; i++) {
             double angle = (2 * Math.PI / numPlayers) * i;
             int spawnX = (int) (radius * Math.cos(angle));
@@ -83,11 +66,6 @@ public class Stickfight extends StatelessGame {
         super.start();
     }
 
-    @Override
-    protected void onStop() {
-        this.scoreMap.forEach((player, score) -> getScore().insertResult(player, score));
-    }
-
     private void generateBridge(int startX, int startY, int startZ) {
         int steps = (int) (radius * 1.5);
         for (int i = 0; i < steps; i++) {
@@ -100,23 +78,19 @@ public class Stickfight extends StatelessGame {
 
     @Override
     protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
-        Player player = playerMoveEvent.getPlayer();
-        if(!spawnPoints.containsKey(player)) {
-            if(playerMoveEvent.getNewPosition().y() < 45) player.teleport(this.getSpawn());
-            if(this.countdownStarted) playerMoveEvent.setCancelled(true);
+        if(!spawnPoints.containsKey(playerMoveEvent.getPlayer())) {
+            playerMoveEvent.setCancelled(true);
             return;
         }
 
         if(isBeforeBeginning) {
-            if(spawnPoints.get(player).distance(playerMoveEvent.getNewPosition()) < 1) return;
+            if(spawnPoints.get(playerMoveEvent.getPlayer()).distance(playerMoveEvent.getNewPosition()) < 1) return;
             playerMoveEvent.setCancelled(true);
-            player.teleport(spawnPoints.get(player));
+            playerMoveEvent.getPlayer().teleport(spawnPoints.get(playerMoveEvent.getPlayer()));
         }
 
         if(playerMoveEvent.getNewPosition().y() < 40) {
-            player.teleport(spawnPoints.get(player));
-            this.scoreMap.putIfAbsent(player, 0);
-            this.scoreMap.put(player, this.scoreMap.get(player) + 1);
+            playerMoveEvent.getPlayer().teleport(spawnPoints.get(playerMoveEvent.getPlayer()));
         }
     }
 

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

@@ -5,8 +5,6 @@ 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.game.stateless.config.restriction.RestrictionHandler;
-import eu.mhsl.minenet.minigames.instance.game.stateless.config.restriction.common.MinimalPlayeramountGameRestriction;
 import eu.mhsl.minenet.minigames.instance.room.Room;
 import eu.mhsl.minenet.minigames.message.component.TranslatedComponent;
 import net.minestom.server.item.Material;
@@ -40,10 +38,4 @@ public class SumoFactory implements GameFactory {
     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);
     }
-
-    @Override
-    public RestrictionHandler globalRestrictions() {
-        return new RestrictionHandler()
-                .addRestriction(new MinimalPlayeramountGameRestriction(2));
-    }
 }

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

@@ -156,7 +156,6 @@ class TrafficLightRace extends StatelessGame {
     @Override
     protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
         if(isBeforeBeginning) return;
-        if(getScore().hasResult(playerMoveEvent.getPlayer())) return;
 
         if(phase.equals(LightPhase.RED) && playerMoveEvent.getNewPosition().z()-0.01 > playerMoveEvent.getPlayer().getPosition().z()) {
             playerMoveEvent.getPlayer().setVelocity(new Vec(0, 8, -15));

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

@@ -1,4 +1,4 @@
-package eu.mhsl.minenet.minigames.instance.game.stateless.types.blockBreakRace;
+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;
@@ -11,30 +11,32 @@ import net.minestom.server.item.Material;
 
 import java.util.Map;
 
-public class BlockBreakRaceFactory implements GameFactory {
-    @Override
-    public TranslatedComponent name() {
-        return TranslatedComponent.byId("game_BlockBreakRace#name");
-    }
+public class TurtleGameFactory implements GameFactory {
 
     @Override
-    public Material symbol() {
-        return Material.DIAMOND_PICKAXE;
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_TurtleGame#name");
     }
 
     @Override
     public TranslatedComponent description() {
-        return TranslatedComponent.byId("game_BlockBreakRace#description");
+        return TranslatedComponent.byId("game_TurtleGame#description");
     }
 
     @Override
     public ConfigManager configuration() {
         return new ConfigManager()
-            .addOption(new NumericOption("height", Material.SCAFFOLDING, TranslatedComponent.byId("optionCommon#height"), 20, 30, 40, 50));
+            .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 BlockBreakRace(configuration.get("height").getAsInt()).setParent(parent);
+        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/score/LowestPointsWinScore.java

@@ -1,16 +0,0 @@
-package eu.mhsl.minenet.minigames.score;
-
-import eu.mhsl.minenet.minigames.util.MapUtil;
-import net.minestom.server.entity.Player;
-
-import java.util.Set;
-
-public class LowestPointsWinScore extends PointsWinScore {
-    @Override
-    protected void insertResultImplementation(Set<Player> p, int currentPoints) {
-        this.scoreOrder.put(p, currentPoints);
-        this.scoreOrder = MapUtil.sortReversedByValue(this.scoreOrder);
-        getScores().clear();
-        this.scoreOrder.forEach((player, integer) -> getScores().addFirst(player));
-    }
-}

src/main/java/eu/mhsl/minenet/minigames/score/PointsWinScore.java

@@ -12,7 +12,7 @@ import java.util.*;
 import java.util.stream.Collectors;
 
 public class PointsWinScore extends Score {
-    Map<Set<Player>, Integer> scoreOrder = new HashMap<>();
+    private Map<Set<Player>, Integer> scoreOrder = new HashMap<>();
 
     @Override
     protected void insertResultImplementation(Set<Player> p, int currentPoints) {

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

@@ -1,6 +1,9 @@
 package eu.mhsl.minenet.minigames.util;
 
-import java.util.*;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
 
 public class MapUtil {
     public static <K, V extends Comparable<? super V>> Map<K, V> sortByValue(Map<K, V> map) {
@@ -14,16 +17,4 @@ public class MapUtil {
 
         return result;
     }
-
-    public static <K, V extends Comparable<? super V>> Map<K, V> sortReversedByValue(Map<K, V> map) {
-        List<Map.Entry<K, V>> list = new ArrayList<>(map.entrySet());
-        list.sort(Map.Entry.<K, V>comparingByValue().reversed());
-
-        Map<K, V> result = new LinkedHashMap<>();
-        for (Map.Entry<K, V> entry : list) {
-            result.put(entry.getKey(), entry.getValue());
-        }
-
-        return result;
-    }
 }

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

@@ -1,28 +1,9 @@
 package eu.mhsl.minenet.minigames.util;
 
-import net.minestom.server.instance.block.BlockFace;
 import net.minestom.server.item.Material;
 
-import java.util.Arrays;
-import java.util.List;
-import java.util.concurrent.ThreadLocalRandom;
-import java.util.function.Predicate;
-
 public class MaterialUtil {
     public static Material fromString(String name, Material def) {
         return Material.values().stream().filter(material -> material.name().equals(name)).findFirst().orElse(def);
     }
-
-    public static Material getRandomFullBlock(Predicate<Material> filter) {
-        List<Material> blocks = Material.values().stream()
-            .filter(filter)
-            .filter(Material::isBlock)
-            .filter(material -> material.block().isSolid())
-            .filter(material -> Arrays.stream(BlockFace.values())
-                .allMatch(face -> material.block().registry().collisionShape().isFaceFull(face))
-            )
-            .toList();
-
-        return blocks.get(ThreadLocalRandom.current().nextInt(blocks.size()));
-    }
 }

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, Block.DANDELION, Block.POPPY, Block.CORNFLOWER}),
+    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/terrain/HeightTerrainGenerator.java

@@ -55,19 +55,7 @@ public class HeightTerrainGenerator extends BaseGenerator {
                 synchronized (batches) {
                     double batchNoise = batches.getNoise(bottomPoint.x(), bottomPoint.z());
 
-                    Block block = batchNoise < 0.9 ? batchNoise > -0.2 ? Block.GRASS_BLOCK : Block.SOUL_SAND : Block.STONE;
-                    unit.modifier().fill(bottomPoint, bottomPoint.add(1, heightModifier, 1), block);
-                    if(rnd.nextInt(0, 5) < 1 && block == Block.GRASS_BLOCK) {
-                        int randomInt = rnd.nextInt(0, 6);
-                        if(randomInt > 1) {
-                            unit.modifier().setBlock(bottomPoint.add(0, heightModifier, 0), Block.SHORT_GRASS);
-                        } else if(randomInt > 0) {
-                            unit.modifier().setBlock(bottomPoint.add(0, heightModifier, 0), BlockPallet.FLOWER.rnd());
-                        } else {
-                            unit.modifier().setBlock(bottomPoint.add(0, heightModifier, 0), Block.TALL_GRASS);
-                            unit.modifier().setBlock(bottomPoint.add(0, heightModifier+1, 0), Block.TALL_GRASS.withProperty("half", "upper"));
-                        }
-                    }
+                    unit.modifier().fill(bottomPoint, bottomPoint.add(1, heightModifier, 1), batchNoise < 0.9 ? batchNoise > 0 ? Block.GRASS_BLOCK : Block.SOUL_SAND : Block.STONE);
 
                     if(calculateSeaLevel != null) {
                         Point absoluteHeight = bottomPoint.add(0, heightModifier, 0);

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

@@ -144,11 +144,7 @@ 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_BlockBreakRace#;;
-name;Block Break Race;Blockbruch-Rennen
-description;Dig down through the tubes using the right tools. The first player to reach the bottom wins!;Grabe dich durch die Röhren nach unten und verwende dabei das richtige Werkzeug. Wer zuerst unten ankommt, gewinnt!
-;;
-ns:game_SpaceSnake#;;
-name;Space Snake;Weltraum-Snake
-description;Collect diamonds while extending your snake bridge through space and fight other players. The player with the longest bridge wins!;Sammle Diamanten, während du deine Schlangenbrücke durchs All erweiterst und gegen andere Spieler kämpfst. Der Spieler mit den der Längsten Brücke gewinnt!
-powerUpCount;Number of diamonds in the arena;Anzahl der Diamanten in der Arena
+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