highground finished

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

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

@@ -8,11 +8,13 @@ import eu.mhsl.minenet.minigames.instance.game.stateless.types.backrooms.Backroo
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.bedwars.BedwarsFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.acidRain.AcidRainFactory;
 import eu.mhsl.minenet.minigames.instance.game.stateless.types.deathcube.DeathcubeFactory;
+import eu.mhsl.minenet.minigames.instance.game.stateless.types.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;
@@ -32,7 +34,9 @@ public enum GameList {
     ACIDRAIN(new AcidRainFactory(), GameType.PVE),
     ELYTRARACE(new ElytraRaceFactory(), GameType.PVP),
     SPLEEF(new SpleefFactory(), GameType.PVP),
-    JUMPDIVE(new JumpDiveFactory(), GameType.JUMPNRUN);
+    JUMPDIVE(new JumpDiveFactory(), GameType.JUMPNRUN),
+    SUMO(new SumoFactory(), GameType.PVP),
+    HIGHGROUND(new HighGroundFactory(), GameType.PVP);
 
     private final GameFactory factory;
     private final GameType type;
@@ -45,6 +49,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/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/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,36 @@
+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 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,36 @@
+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 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,7 +106,7 @@ 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);
         }
     }
 
@@ -114,15 +114,15 @@ class Tetris extends StatelessGame {
         TetrisGame tetrisGame = this.tetrisGames.get(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 +134,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/Cursor.java

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -15,7 +15,6 @@ import net.minestom.server.MinecraftServer;
 import net.minestom.server.coordinate.Pos;
 import net.minestom.server.entity.GameMode;
 import net.minestom.server.entity.Player;
-import net.minestom.server.entity.attribute.Attribute;
 import net.minestom.server.event.player.PlayerBlockBreakEvent;
 import net.minestom.server.event.player.PlayerDisconnectEvent;
 import net.minestom.server.instance.anvil.AnvilLoader;
@@ -67,9 +66,6 @@ public class Room extends MineNetInstance implements Spawnable {
         p.getInventory().clear();
         p.setGameMode(GameMode.ADVENTURE);
         p.setInvisible(false);
-        p.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).setBaseValue(p.getAttribute(Attribute.BLOCK_INTERACTION_RANGE).attribute().defaultValue());
-        p.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).setBaseValue(p.getAttribute(Attribute.ENTITY_INTERACTION_RANGE).attribute().defaultValue());
-        p.heal();
         p.setExp(0);
         p.setLevel(0);
         rooms.add(room);
@@ -94,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) {
@@ -129,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(
@@ -139,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/resources/lang/locales.map.csv

@@ -130,3 +130,12 @@ 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!