fixed extra space in lambda expression in SpaceSnake spawn calculation

Reviewed-on: #3
Reviewed-by: Lars Neuhaus <larslukasneuhaus@gmx.de>

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

@@ -2,6 +2,7 @@ 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;
@@ -12,6 +13,7 @@ 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;
@@ -38,7 +40,9 @@ public enum GameList {
     JUMPDIVE(new JumpDiveFactory(), GameType.JUMPNRUN),
     SUMO(new SumoFactory(), GameType.PVP),
     HIGHGROUND(new HighGroundFactory(), GameType.PVP),
-    FASTBRIDGE(new FastbridgeFactory(), GameType.OTHER);
+    FASTBRIDGE(new FastbridgeFactory(), GameType.OTHER),
+    BLOCKBREAKRACE(new BlockBreakRaceFactory(), GameType.OTHER),
+    SPACESNAKE(new SpaceSnakeFactory(), GameType.PVP);
 
     private final GameFactory factory;
     private final GameType type;

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

@@ -0,0 +1,79 @@
+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/BlockBreakRaceFactory.java

@@ -0,0 +1,40 @@
+package eu.mhsl.minenet.minigames.instance.game.stateless.types.blockBreakRace;
+
+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 BlockBreakRaceFactory implements GameFactory {
+    @Override
+    public TranslatedComponent name() {
+        return TranslatedComponent.byId("game_BlockBreakRace#name");
+    }
+
+    @Override
+    public Material symbol() {
+        return Material.DIAMOND_PICKAXE;
+    }
+
+    @Override
+    public TranslatedComponent description() {
+        return TranslatedComponent.byId("game_BlockBreakRace#description");
+    }
+
+    @Override
+    public ConfigManager configuration() {
+        return new ConfigManager()
+            .addOption(new NumericOption("height", Material.SCAFFOLDING, TranslatedComponent.byId("optionCommon#height"), 20, 30, 40, 50));
+    }
+
+    @Override
+    public Game manufacture(Room parent, Map<String, Option<?>> configuration) throws Exception {
+        return new BlockBreakRace(configuration.get("height").getAsInt()).setParent(parent);
+    }
+}

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

@@ -0,0 +1,67 @@
+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/spaceSnake/SpaceSnake.java

@@ -0,0 +1,181 @@
+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 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.display.BlockDisplayMeta;
+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.instance.block.BlockFace;
+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> playerBlocks = 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 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)),
+            this.getRandomBlock(),
+            spawn
+        );
+        this.playerBlocks.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.playerBlocks.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);
+        }
+    }
+
+    @Override
+    protected void onBlockPlace(@NotNull PlayerBlockPlaceEvent playerBlockPlaceEvent) {
+        if(this.isBeforeBeginning) {
+            playerBlockPlaceEvent.setCancelled(true);
+            return;
+        }
+
+        PlayState state = this.playerBlocks.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.playerBlocks.get(player).blockType, 64));
+    }
+
+    private Material getRandomBlock() {
+        List<Material> blocks = Material.values().stream()
+            .filter(Material::isBlock)
+            .filter(material -> material.registry().block() != null)
+            .filter(material -> material.block().isSolid())
+            .filter(material -> Arrays.stream(BlockFace.values())
+                .allMatch(face -> material.block().registry().collisionShape().isFaceFull(face))
+            )
+            .toList();
+        return blocks.get(this.rnd.nextInt(blocks.size()));
+    }
+
+    private void spawnPowerUp() {
+        Pos spawnPos = new Pos(this.posInBoundsW.get(), this.posInBoundsH.get(), this.posInBoundsW.get());
+        Entity display = new Entity(EntityType.BLOCK_DISPLAY);
+        ((BlockDisplayMeta) display.getEntityMeta()).setBlockState(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.getDistance(onTick.getEntity()) < 2.5)
+                .findAny()
+                .orElse(null);
+            if(player == null) return;
+
+            this.spawnPowerUp();
+            display.remove();
+            this.onPowerup(player);
+        });
+    }
+
+    private void onPowerup(Player player) {
+        PlayState state = this.playerBlocks.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

@@ -0,0 +1,41 @@
+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/tetris/Tetris.java

@@ -112,9 +112,11 @@ class Tetris extends StatelessGame {
 
     private void letPlayerLoose(Player player) {
         TetrisGame tetrisGame = this.tetrisGames.get(player);
-        player.setGameMode(GameMode.SPECTATOR);
-        player.setInvisible(true);
-        this.getScore().insertResult(player, tetrisGame.getScore());
+        if(!this.getScore().hasResult(player)) {
+            player.setGameMode(GameMode.SPECTATOR);
+            player.setInvisible(true);
+            this.getScore().insertResult(player, tetrisGame.getScore());
+        }
 
         boolean allGamesLost = this.tetrisGames.values().stream()
             .filter(game -> !game.lost)

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

@@ -143,3 +143,12 @@ description;Stay on the high ground to win!;Bleibe solange wie möglich auf der
 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