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

@@ -3,12 +3,25 @@ package eu.mhsl.minenet.minigames.score;
 import eu.mhsl.minenet.minigames.util.MapUtil;
 import net.minestom.server.entity.Player;
 
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Objects;
 import java.util.Set;
 
 public class LowestPointsWinScore extends PointsWinScore {
     @Override
     protected void insertResultImplementation(Set<Player> p, int currentPoints) {
-        this.scoreOrder.put(p, currentPoints);
+        Set<Player> combined = scoreOrder.entrySet().stream()
+                .filter(entrySet -> Objects.equals(entrySet.getValue(), currentPoints))
+                .map(Map.Entry::getKey)
+                .findFirst()
+                .orElseGet(() -> {
+                    Set<Player> s = new HashSet<>();
+                    scoreOrder.put(s, currentPoints);
+                    return s;
+                });
+        combined.addAll(p);
+
         this.scoreOrder = MapUtil.sortReversedByValue(this.scoreOrder);
         getScores().clear();
         this.scoreOrder.forEach((player, integer) -> getScores().addFirst(player));

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

@@ -16,7 +16,17 @@ public class PointsWinScore extends Score {
 
     @Override
     protected void insertResultImplementation(Set<Player> p, int currentPoints) {
-        this.scoreOrder.put(p, currentPoints);
+        Set<Player> combined = scoreOrder.entrySet().stream()
+            .filter(entrySet -> Objects.equals(entrySet.getValue(), currentPoints))
+            .map(Map.Entry::getKey)
+            .findFirst()
+            .orElseGet(() -> {
+                Set<Player> s = new HashSet<>();
+                scoreOrder.put(s, currentPoints);
+                return s;
+            });
+        combined.addAll(p);
+
         this.scoreOrder = MapUtil.sortByValue(this.scoreOrder);
         getScores().clear();
         this.scoreOrder.forEach((player, integer) -> getScores().addFirst(player));
@@ -42,13 +52,12 @@ public class PointsWinScore extends Score {
                         .filter(player -> !player.getUsername().isBlank())
                         .toList()
                         .isEmpty())
-                    .map(players -> players
-                        .stream()
-                        .filter(player -> scoreOrder.get(Set.of(player)) != null)
-                        .map(player -> player.getUsername()+" :  "+scoreOrder.get(Set.of(player)).toString())
-                        .collect(Collectors.joining(", "))
-                    )
-                    .toList()
+                        .map(players -> players.stream()
+                                .map(Player::getUsername)
+                                .sorted()
+                                .collect(Collectors.joining(", "))
+                                + " :  " + scoreOrder.get(players)
+                        ).toList()
             )
             .undent()
             .newLine()

src/main/java/eu/mhsl/minenet/minigames/score/tournament/Tournament.java

@@ -4,6 +4,7 @@ import eu.mhsl.minenet.minigames.score.Score;
 import net.minestom.server.entity.Player;
 
 import java.util.*;
+import java.util.stream.Collectors;
 
 public class Tournament {
     private final List<Score> gameScores = new ArrayList<>();
@@ -43,9 +44,11 @@ public class Tournament {
     public Rewards getRewards() {
         Map<UUID, Integer> itemCount = new HashMap<>();
         int count = 0;
-        for (Player player : getPlaces()) {
+        for (Set<Player> players : getPlaces()) {
             if(count >= this.rewardConfiguration.rewardCount().size()) break;
-            itemCount.put(player.getUuid(), this.rewardConfiguration.rewardCount().get(count));
+            for(Player player : players) {
+                itemCount.put(player.getUuid(), this.rewardConfiguration.rewardCount().get(count));
+            }
             count++;
         }
 
@@ -53,18 +56,21 @@ public class Tournament {
                 this.memorialConfiguration.memorialMaterial().namespace().value(),
                 this.memorialConfiguration.memorialTitle(),
                 this.memorialConfiguration.memorialLore(),
-                getPlaces().stream().map(Player::getUuid).toList(),
+                getGameScores().keySet().stream().map(Player::getUuid).toList(),
                 this.rewardConfiguration.item().namespace().value(),
                 itemCount
         );
     }
 
-    public List<Player> getPlaces() {
-        List<Player> players = new ArrayList<>(
+    public List<Set<Player>> getPlaces() {
+        List<Set<Player>> players = new ArrayList<>(
                 getGameScores().entrySet().stream()
-                    .sorted(Map.Entry.comparingByValue())
-                    .map(Map.Entry::getKey)
-                    .toList()
+                        .collect(
+                                Collectors.groupingBy(
+                                        Map.Entry::getValue,
+                                        Collectors.mapping(Map.Entry::getKey, Collectors.toSet())
+                                )
+                        ).values()
         );
 
         Collections.reverse(players);

src/main/java/eu/mhsl/minenet/minigames/score/tournament/TournamentDisplay.java

@@ -12,10 +12,12 @@ import net.minestom.server.entity.*;
 import net.minestom.server.event.player.PlayerMoveEvent;
 import net.minestom.server.instance.anvil.AnvilLoader;
 
+import java.util.Comparator;
 import java.util.List;
+import java.util.Set;
 
 public class TournamentDisplay extends MineNetInstance implements Spawnable {
-    private final List<Player> places;
+    private final List<Set<Player>> places;
     private final Tournament tournament;
 
     private final Pos[] placePositions = new Pos[] {
@@ -30,7 +32,7 @@ public class TournamentDisplay extends MineNetInstance implements Spawnable {
         this.places = tournament.getPlaces();
         this.tournament = tournament;
 
-        this.places.forEach(player -> player.setGameMode(GameMode.ADVENTURE));
+        this.places.forEach(players -> players.forEach(player -> player.setGameMode(GameMode.ADVENTURE)));
 
         eventNode().addListener(PlayerMoveEvent.class, playerMoveEvent -> {
             if(isOnDisplay(playerMoveEvent.getPlayer()) && !playerMoveEvent.getNewPosition().sameBlock(placePositions[getRankPosition(playerMoveEvent.getPlayer())])) {
@@ -45,7 +47,10 @@ public class TournamentDisplay extends MineNetInstance implements Spawnable {
     }
 
     private int getRankPosition(Player player) {
-        return this.places.indexOf(player);
+        for (int i = 0; i < places.size(); i++) {
+            if (places.get(i).contains(player)) return i;
+        }
+        return -1;
     }
 
     @Override
@@ -56,8 +61,11 @@ public class TournamentDisplay extends MineNetInstance implements Spawnable {
                 p.teleport(placePositions[getRankPosition(p)]);
             }
         });
+        List<Player> players = this.places.stream()
+                .flatMap(s -> s.stream().sorted(Comparator.comparing(Player::getUsername)))
+                .toList();
         new ChatMessage(Icon.STAR)
-                .numberedList(this.places.stream().map(player -> String.format("%s - %s Punkte", player.getUsername(), tournament.getGameScores().get(player))).toList())
+                .list(players.stream().map(player -> String.format("%d. %s - %s Punkte", this.getRankPosition(player)+1, player.getUsername(), tournament.getGameScores().get(player))).toList())
                 .send(p);
         return false;
     }