Refactored score system

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

@@ -61,7 +61,7 @@ class Deathcube extends StatelessGame {
     protected void onPlayerMove(@NotNull PlayerMoveEvent playerMoveEvent) {
         super.onPlayerMove(playerMoveEvent);
         if(isBeforeBeginning) if(playerMoveEvent.getNewPosition().y() > 51.5) playerMoveEvent.setCancelled(true);
-        if(playerMoveEvent.getNewPosition().y() > height) getScore().addResult(playerMoveEvent.getPlayer());
+        if(playerMoveEvent.getNewPosition().y() > height) getScore().insertResult(playerMoveEvent.getPlayer());
     }
 
     @Override

src/main/java/eu/mhsl/minenet/minigames/instance/game/stateless/types/minerun/Minerun.java

@@ -94,14 +94,13 @@ class Minerun extends StatelessGame {
             new ActionBarMessage().appendStatic(Component.text("Please stay in line!", NamedTextColor.RED)).send(p);
         }
 
-        if(!isRunning && middle.z() > preRun+0.5) { //player cannot go forward before game start
+        if(!isRunning && middle.z() > preRun+0.5) { //player cannot go forward before the game start
             playerMoveEvent.setCancelled(true);
         }
 
-        if(middle.z() < preRun + length + afterMines) { // player cannot go back
+        if(middle.z() < preRun + length + afterMines && getScore().hasResult(p)) { // player cannot go back after winning
-//            playerMoveEvent.setCancelled(true);
+            playerMoveEvent.setCancelled(true);
-//            new ActionBarMessage().appendStatic(Component.text("You cannot go back on the Field!", NamedTextColor.RED)).send(p);
+            new ActionBarMessage().appendStatic(Component.text("You cannot go back on the Field!", NamedTextColor.RED)).send(p);
-            return;
         }
 
         if(Intersect.withPressurePlate(this, BlockPallet.PRESSURE_PLATES, middle)) { //Player died
@@ -111,7 +110,7 @@ class Minerun extends StatelessGame {
         }
 
         if(middle.z() > preRun + length + afterMines) { // Player finished
-            getScore().addResult(p);
+            getScore().insertResult(p);
         }
     }
 

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

@@ -26,7 +26,8 @@ public class Spleef extends StatelessGame {
     final int totalElevation = 50;
 
     public Spleef(int radius, int stackCount) {
-        super(Dimension.OVERWORLD.DIMENSION, "Spleef", new LastWinsScore(1));
+        super(Dimension.OVERWORLD.DIMENSION, "Spleef", new LastWinsScore());
+        getScore().setIgnoreLastPlayers(1);
 
         this.radius = radius;
         this.stackCount = stackCount;
@@ -78,7 +79,7 @@ public class Spleef extends StatelessGame {
         if(playerMoveEvent.getNewPosition().y() < totalElevation) {
             playerMoveEvent.getPlayer().setGameMode(GameMode.SPECTATOR);
             playerMoveEvent.getPlayer().getInventory().clear();
-            getScore().addResult(playerMoveEvent.getPlayer());
+            getScore().insertResult(playerMoveEvent.getPlayer());
         }
     }
 

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

@@ -1,46 +1,20 @@
 package eu.mhsl.minenet.minigames.score;
 
+import eu.mhsl.minenet.minigames.message.TranslatableMessage;
 import eu.mhsl.minenet.minigames.message.type.TitleMessage;
 import net.minestom.server.entity.Player;
 
 import java.time.Duration;
-import java.util.ArrayList;
+import java.util.Set;
-import java.util.List;
 
 public class FirstWinsScore extends Score {
-    private List<Player> scores = new ArrayList<>();
+    @Override
-    private int ignoreLastPlayers = 0;
+    public void insertResultImplementation(Set<Player> p) {
-
+        getScores().add(p);
-
-    public FirstWinsScore() {}
-
-    public FirstWinsScore(int ignoreLastPlayers) {
-        this.ignoreLastPlayers = ignoreLastPlayers;
-    }
-
-    public void setIgnoreLastPlayers(int ignoreLastPlayers) {
-        this.ignoreLastPlayers = ignoreLastPlayers;
     }
 
     @Override
-    protected void checkGameEnd() {
+    protected TranslatableMessage scoreMessage() {
-        if(this.isDone()) return;
+        return new TitleMessage(Duration.ofMillis(1000), Duration.ofSeconds(1)).appendTranslated("score#finish");
-        if(instance.getPlayers().isEmpty()) return;
-        if(scores.size() >= instance.getPlayers().size() - ignoreLastPlayers) setDone();
-    }
-
-    @Override
-    public void addResult(Player p) {
-        if(scores.contains(p)) return;
-        scores.add(p);
-
-        new TitleMessage(Duration.ofMillis(1000), Duration.ofSeconds(1)).appendTranslated("score#finish").send(p);
-
-        this.checkGameEnd();
-    }
-
-    @Override
-    protected List<String> getResults() {
-        return scores.stream().map(Player::getUsername).toList();
     }
 }

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

@@ -1,47 +1,20 @@
 package eu.mhsl.minenet.minigames.score;
 
+import eu.mhsl.minenet.minigames.message.TranslatableMessage;
 import eu.mhsl.minenet.minigames.message.type.TitleMessage;
 import net.minestom.server.entity.Player;
 
 import java.time.Duration;
-import java.util.ArrayList;
+import java.util.Set;
-import java.util.List;
 
 public class LastWinsScore extends Score {
-    private List<Player> scores = new ArrayList<>();
+    @Override
-    private int ignoreLastPlayers = 0;
+    public void insertResultImplementation(Set<Player> p) {
-
+        getScores().add(0, p);
-    public LastWinsScore() {}
-
-    public LastWinsScore(int ignoreLastPlayers) {
-        this.ignoreLastPlayers = ignoreLastPlayers;
     }
 
     @Override
-    protected void checkGameEnd() {
+    protected TranslatableMessage scoreMessage() {
-        if(this.isDone()) return;
+        return new TitleMessage(Duration.ofMillis(1000), Duration.ofSeconds(1)).appendTranslated("score#death");
-        if(!instance.isRunning()) return;
-        if(instance.getPlayers().isEmpty()) return;
-        if(scores.size() >= instance.getPlayers().size() - ignoreLastPlayers) {
-            if(ignoreLastPlayers > 0) {
-                instance.getPlayers().stream().filter(player -> !scores.contains(player)).forEach(this::addResult);
-            }
-            setDone();
-        }
-    }
-
-    @Override
-    public void addResult(Player p) {
-        if(scores.contains(p)) return;
-        scores.add(0, p);
-
-        new TitleMessage(Duration.ofMillis(1000), Duration.ofSeconds(1)).appendTranslated("score#death").send(p);
-
-        this.checkGameEnd();
-    }
-
-    @Override
-    protected List<String> getResults() {
-        return scores.stream().map(Player::getUsername).toList();
     }
 }

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

@@ -1,8 +1,9 @@
 package eu.mhsl.minenet.minigames.score;
 
+import eu.mhsl.minenet.minigames.message.TranslatableMessage;
 import net.minestom.server.entity.Player;
 
-import java.util.List;
+import java.util.Set;
 
 public class NoScore extends Score {
     @Override
@@ -10,12 +11,14 @@ public class NoScore extends Score {
     }
 
     @Override
-    public void addResult(Player p) {
+    public void insertResultImplementation(Set<Player> p) {
 
     }
 
     @Override
-    protected List<String> getResults() {
+    protected TranslatableMessage scoreMessage() {
         return null;
     }
+
+
 }

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

@@ -2,17 +2,30 @@ package eu.mhsl.minenet.minigames.score;
 
 import eu.mhsl.minenet.minigames.instance.game.Game;
 import eu.mhsl.minenet.minigames.message.Icon;
+import eu.mhsl.minenet.minigames.message.TranslatableMessage;
 import eu.mhsl.minenet.minigames.message.type.ChatMessage;
 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 java.util.ArrayList;
 import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
 
 public abstract class Score {
-    private boolean isDone = false;
+    private int ignoreLastPlayers = 0;
+    private boolean isClosed = false;
     protected Game instance;
+    private List<Set<Player>> scores = new ArrayList<>();
+
+    public Score() {}
+
+    public Score(int ignoreLastPlayers) {
+        this.ignoreLastPlayers = ignoreLastPlayers;
+    }
+
 
     public void attachListeners() {
         this.instance.eventNode()
@@ -21,22 +34,57 @@ public abstract class Score {
                 .addListener(PlayerDisconnectEvent.class, addEntityToInstanceEvent -> checkGameEnd());
     }
 
-    abstract protected void checkGameEnd();
+    protected void checkGameEnd() {
-    public abstract void addResult(Player p);
+        if(this.isClosed()) return;
-    abstract protected List<String> getResults();
+        if(!instance.isRunning()) return;
+        if(instance.getPlayers().isEmpty()) return;
+        if(resultCount() >= instance.getPlayers().size() - ignoreLastPlayers) {
+            if(ignoreLastPlayers > 0) {
+                insertRemainingPlayers(instance.getPlayers().stream().filter(player -> !hasResult(player)).collect(Collectors.toSet()));
+            }
+            setDone();
+        }
+    }
+    protected abstract void insertResultImplementation(Set<Player> p);
+    protected abstract TranslatableMessage scoreMessage();
 
-    public boolean isDone() {
+    public void insertResult(Player p) {
-        return isDone;
+        if(hasResult(p)) return;
+        this.scoreMessage().send(p);
+        this.insertResultImplementation(Set.of(p));
+        this.checkGameEnd();
+    }
+
+    private void insertRemainingPlayers(Set<Player> p) {
+        if(p.stream().anyMatch(this::hasResult)) return;
+        this.insertResultImplementation((p));
+    }
+
+    public boolean hasResult(Player p) {
+        return this.getScores().stream().anyMatch(players -> players.contains(p));
+    }
+
+    public int resultCount() {
+        return this.getScores().stream().map(Set::size).reduce(Integer::sum).orElse(0);
     }
 
     public void setDone() {
-        if(isDone) return;
+        if(isClosed) return;
-        isDone = true;
+        isClosed = true;
         new ChatMessage(Icon.STAR, true)
                 .appendTranslated("score#result")
                 .newLine()
                 .indent()
-                .numberedList(getResults())
+                .numberedList(
+                        getScores()
+                                .stream()
+                                .map(players -> players
+                                        .stream()
+                                        .map(Player::getUsername)
+                                        .collect(Collectors.joining(", "))
+                                )
+                                .toList()
+                )
                 .undent()
                 .newLine()
                 .appendTranslated("score#thanks")
@@ -45,11 +93,27 @@ public abstract class Score {
         instance.stop();
     }
 
+    public boolean isClosed() {
+        return isClosed;
+    }
+
     protected void onGameEnd() {
         this.instance.stop();
     }
 
+    public List<Set<Player>> getScores() {
+        return scores;
+    }
+
     public void setInstance(Game instance) {
         this.instance = instance;
     }
+
+    public int getIgnoreLastPlayers() {
+        return ignoreLastPlayers;
+    }
+
+    public void setIgnoreLastPlayers(int ignoreLastPlayers) {
+        this.ignoreLastPlayers = ignoreLastPlayers;
+    }
 }