fixed score

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

@@ -16,9 +16,7 @@ import net.minestom.server.item.ItemStack;
 import net.minestom.server.item.Material;
 import org.jetbrains.annotations.NotNull;
 
-import java.util.Map;
+import java.util.*;
-import java.util.Random;
-import java.util.WeakHashMap;
 
 class Tetris extends StatelessGame {
     private final Map<Player, TetrisGame> tetrisGames = new WeakHashMap<>();
@@ -42,6 +40,8 @@ class Tetris extends StatelessGame {
 
         Random random = new Random();
         this.randomSeed = random.nextLong();
+
+        System.out.println("1");
     }
 
     @Override
@@ -68,21 +68,23 @@ class Tetris extends StatelessGame {
 
     @Override
     protected void onPlayerLeave(Player p) {
+        System.out.println("2");
         this.tetrisGames.get(p).sidebar.removeViewer(p);
         this.letPlayerLoose(p);
     }
 
     @Override
     protected void onPlayerMove(@NotNull PlayerMoveEvent event) {
-        event.setCancelled(true);
-
         Player player = event.getPlayer();
         Pos previousPosition = event.getPlayer().getPosition();
         Pos currentPosition = event.getNewPosition();
 
         TetrisGame tetrisGame = this.tetrisGames.get(player);
 
-        if(tetrisGame == null) return;
+        if(tetrisGame == null) {
+            event.setCancelled(true);
+            return;
+        }
         if(tetrisGame.lost) return;
         if(player.getGameMode() == GameMode.SPECTATOR) return;
 
@@ -132,11 +134,13 @@ class Tetris extends StatelessGame {
         TetrisGame tetrisGame = this.tetrisGames.get(player);
         if(tetrisGame == null) return;
         if(tetrisGame.lost && player.getGameMode() != GameMode.SPECTATOR) {
+            System.out.println("3");
             letPlayerLoose(player);
         }
     }
 
     private void letPlayerLoose(Player player) {
+        System.out.println("4");
         TetrisGame tetrisGame = this.tetrisGames.get(player);
         player.setGameMode(GameMode.SPECTATOR);
         player.setInvisible(true);
@@ -167,8 +171,10 @@ class Tetris extends StatelessGame {
                 this.hasCombat,
                 this.randomSeed
             );
-            this.tetrisGames.get(p).generate();
+            newTetrisGame.generate();
-            this.tetrisGames.values().forEach(tetrisGame -> tetrisGame.updateOtherTetrisGames(this.tetrisGames.values()));
+            List<TetrisGame> games = new ArrayList<>(this.tetrisGames.values());
+            games.add(newTetrisGame);
+            this.tetrisGames.values().forEach(tetrisGame -> tetrisGame.updateOtherTetrisGames(games));
             return newTetrisGame;
         });
 

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

@@ -8,21 +8,11 @@ import java.time.Duration;
 import java.util.Set;
 
 public class FirstWinsScore extends Score {
-    @Override
-    public void insertResultImplementation(Set<Player> p, int points) {
-
-    }
-
     @Override
     public void insertResultImplementation(Set<Player> p) {
         getScores().add(p);
     }
 
-    @Override
-    public void insertResult(Player p, int points) {
-
-    }
-
     @Override
     protected TranslatableMessage scoreMessage() {
         return new TitleMessage(Duration.ofMillis(1000), Duration.ofSeconds(1)).appendTranslated("score#finish");

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

@@ -8,21 +8,11 @@ import java.time.Duration;
 import java.util.Set;
 
 public class LastWinsScore extends Score {
-    @Override
-    public void insertResultImplementation(Set<Player> p, int points) {
-
-    }
-
     @Override
     public void insertResultImplementation(Set<Player> p) {
         getScores().addFirst(p);
     }
 
-    @Override
-    public void insertResult(Player p, int points) {
-
-    }
-
     @Override
     protected TranslatableMessage scoreMessage() {
         return new TitleMessage(Duration.ofMillis(1000), Duration.ofSeconds(1)).appendTranslated("score#death");

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

@@ -10,21 +10,11 @@ public class NoScore extends Score {
     protected void checkGameEnd() {
     }
 
-    @Override
-    public void insertResultImplementation(Set<Player> p, int points) {
-
-    }
-
     @Override
     public void insertResultImplementation(Set<Player> p) {
 
     }
 
-    @Override
-    public void insertResult(Player p, int points) {
-
-    }
-
     @Override
     protected TranslatableMessage scoreMessage() {
         return null;

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

@@ -15,8 +15,8 @@ public class PointsWinScore extends Score {
     private Map<Set<Player>, Integer> scoreOrder = new HashMap<>();
 
     @Override
-    public void insertResultImplementation(Set<Player> p, int points) {
+    protected void insertResultImplementation(Set<Player> p, int currentPoints) {
-        this.scoreOrder.put(p, points);
+        this.scoreOrder.put(p, currentPoints);
         this.scoreOrder = MapUtil.sortByValue(this.scoreOrder);
         getScores().clear();
         this.scoreOrder.forEach((player, integer) -> getScores().addFirst(player));
@@ -27,14 +27,6 @@ public class PointsWinScore extends Score {
         this.insertResultImplementation(p, 0);
     }
 
-    @Override
-    public void insertResult(Player p, int points) {
-        if(hasResult(p)) return;
-        this.scoreMessage().send(p);
-        this.insertResultImplementation(Set.of(p), points);
-        this.checkGameEnd();
-    }
-
     @Override
     public void setDone() {
         if(isClosed()) return;

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

@@ -8,6 +8,7 @@ import net.minestom.server.entity.Player;
 import net.minestom.server.event.instance.AddEntityToInstanceEvent;
 import net.minestom.server.event.instance.RemoveEntityFromInstanceEvent;
 import net.minestom.server.event.player.PlayerDisconnectEvent;
+import org.apache.commons.lang3.NotImplementedException;
 
 import java.util.ArrayList;
 import java.util.List;
@@ -22,10 +23,19 @@ public abstract class Score {
 
     public Score() {}
 
-    public Score(int ignoreLastPlayers) {
+    protected abstract void insertResultImplementation(Set<Player> p);
-        this.ignoreLastPlayers = ignoreLastPlayers;
+
+    protected void insertResultImplementation(Set<Player> p, int points) {
+        throw new NotImplementedException("This Score type is not able to process points");
     }
 
+    public void insertResult(Player p) {
+        this.insertResultProcessor(p, () -> this.insertResultImplementation(Set.of(p)));
+    }
+
+    public void insertResult(Player p, int points) {
+        this.insertResultProcessor(p, () -> this.insertResultImplementation(Set.of(p), points));
+    }
 
     public void attachListeners() {
         this.instance.eventNode()
@@ -46,21 +56,8 @@ public abstract class Score {
         }
     }
 
-    public abstract void insertResultImplementation(Set<Player> p, int points);
-
-    protected abstract void insertResultImplementation(Set<Player> p);
-
-    public abstract void insertResult(Player p, int points);
-
     protected abstract TranslatableMessage scoreMessage();
 
-    public void insertResult(Player p) {
-        if(hasResult(p)) return;
-        this.scoreMessage().send(p);
-        this.insertResultImplementation(Set.of(p));
-        this.checkGameEnd();
-    }
-
     public void insertRemainingPlayers(Set<Player> players) {
         this.insertResultImplementation(players.stream().filter(p -> !hasResult(p)).collect(Collectors.toSet()));
         setDone();
@@ -99,6 +96,13 @@ public abstract class Score {
         instance.stop();
     }
 
+    private void insertResultProcessor(Player p, Runnable callback) {
+        if(hasResult(p)) return;
+        this.scoreMessage().send(p);
+        callback.run();
+        this.checkGameEnd();
+    }
+
     public boolean isClosed() {
         return isClosed;
     }