Refactored score system

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();
-    public abstract void addResult(Player p);
-    abstract protected List<String> getResults();
+    protected void checkGameEnd() {
+        if(this.isClosed()) return;
+        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() {
-        return isDone;
+    public void insertResult(Player p) {
+        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;
-        isDone = true;
+        if(isClosed) return;
+        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;
+    }
 }