Moved async runner to virtual thread

app/src/main/java/org/toop/app/Server.java

@@ -11,6 +11,7 @@ import org.toop.app.widget.popup.ErrorPopup;
 import org.toop.app.widget.popup.SendChallengePopup;
 import org.toop.app.widget.view.ServerView;
 import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.game.players.ArtificialPlayer;
 import org.toop.framework.game.players.OnlinePlayer;
 import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.eventbus.GlobalEventBus;
@@ -20,6 +21,7 @@ import org.toop.framework.networking.connection.events.NetworkEvents;
 import org.toop.framework.networking.connection.types.NetworkingConnector;
 import org.toop.framework.networking.server.gateway.NettyGatewayServer;
 import org.toop.framework.game.players.LocalPlayer;
+import org.toop.game.players.ai.MCTSAI3;
 import org.toop.local.AppContext;
 
 import java.util.Arrays;
@@ -208,7 +210,8 @@ public final class Server {
             information.players[opponentStartingTurn].name = response.opponent();
 
             Player[] players = new Player[2];
-            players[userStartingTurn] = new LocalPlayer(user);
+
+            players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(100), user);
             players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
 
             switch (type) {
@@ -244,7 +247,8 @@ public final class Server {
     private void handleTournamentResult(NetworkEvents.TournamentResultResponse response) {
         IO.println(response.gameType());
         IO.println(Arrays.toString(response.names()));
-        IO.println(Arrays.toString(response.scores()));
+		IO.println(Arrays.toString(response.scoreTypes()));
+        IO.println(Arrays.toString(response.scores().toArray()));
     }
 
     private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {

framework/src/main/java/org/toop/framework/networking/connection/events/NetworkEvents.java

@@ -65,7 +65,7 @@ public class NetworkEvents extends EventsBase {
     public record GameResultResponse(long clientId, String condition)
             implements GenericEvent {}
 
-    public record TournamentResultResponse(long clientId, String gameType, String[] names, Integer[] scores)
+    public record TournamentResultResponse(long clientId, String gameType, String[] names, String[] scoreTypes, List<Integer[]> scores)
             implements GenericEvent {}
 
     /** Indicates that a game move has been processed or received. */

framework/src/main/java/org/toop/framework/networking/connection/handlers/NetworkingGameClientHandler.java

@@ -3,7 +3,9 @@ package org.toop.framework.networking.connection.handlers;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
@@ -117,10 +119,13 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
     }
 
     private void resultsHandler(String rec) {
+        // TODO all of this
+
         IO.println(rec);
 
         String gameTypeRaw = extract(rec, "GAMETYPE");
         String usersRaw = extract(rec, "USERS");
+        String scoreTypesRaw = extract(rec, "SCORETYPES");
         String scoresRaw = extract(rec, "SCORES");
 
         if (usersRaw == null) return;
@@ -134,16 +139,32 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
             users = new String[]{};
         }
 
+        String[] scoreTypes;
+        if (scoreTypesRaw.length() > 2) {
+            scoreTypes = Arrays.stream(scoreTypesRaw.substring(1, usersRaw.length() - 1).split(","))
+                    .map(s -> s.trim().replace("\"", ""))
+                    .toArray(String[]::new);
+        } else {
+            scoreTypes = new String[]{};
+        }
+
         if (scoresRaw == null) return;
         if (scoresRaw.length() > 2) {
-            Integer[] scores = Arrays.stream(scoresRaw.substring(1, scoresRaw.length() - 1).split(","))
+            List<Integer[]> scores = Arrays.stream(
+                            scoresRaw.substring(1, scoresRaw.length() - 1) // remove outer []
+                                    .split("\\],\\[")
+                    )
+                    .map(part -> part.replace("[", "").replace("]", ""))
+                    .map(part -> Arrays.stream(part.split(","))
                             .map(String::trim)
                             .map(Integer::parseInt)
-                    .toArray(Integer[]::new);
+                            .toArray(Integer[]::new)
+                    )
+                    .toList();
 
-            eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scores));
+            eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scoreTypes, scores));
         } else {
-            eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, new Integer[]{}));
+            eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scoreTypes, new ArrayList<>()));
         }
 
     }

framework/src/main/java/org/toop/framework/networking/server/Server.java

@@ -11,9 +11,8 @@ import org.toop.framework.networking.server.stores.SubscriptionStore;
 import org.toop.framework.networking.server.stores.TurnBasedGameStore;
 import org.toop.framework.networking.server.stores.TurnBasedGameTypeStore;
 import org.toop.framework.networking.server.tournaments.*;
-import org.toop.framework.networking.server.tournaments.matchmakers.RoundRobinMatchMaker;
-import org.toop.framework.networking.server.tournaments.scoresystems.BasicScoreSystem;
-import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
+import org.toop.framework.networking.server.tournaments.matchmakers.DoubleRoundRobinMatchMaker;
+import org.toop.framework.networking.server.tournaments.scoresystems.*;
 import org.toop.framework.utils.ImmutablePair;
 
 import java.util.*;
@@ -297,10 +296,13 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
         Tournament tournament = new Tournament.Builder()
                 .matchExecutor(this::startGame)
                 .tournamentRunner(new AsyncTournamentRunner())
-                .matchMaker(new RoundRobinMatchMaker())
-                .scoreSystem(new BasicScoreSystem())
+                .matchMaker(new DoubleRoundRobinMatchMaker())
+                .addScoreSystem(new MatchCountScoreSystem())
+                .addScoreSystem(new WinCountScoreSystem())
+                .addScoreSystem(new DrawCountScoreSystem())
+                .addScoreSystem(new LoseCountScoreSystem())
                 .resultBroadcaster(this::endTournament)
-                .turnTimeout(Duration.ofSeconds(5))
+                .turnTimeout(Duration.ofSeconds(10))
                 .addPlayers(tournamentUsers.toArray(NettyClient[]::new))
                 .addAdmins(admins.toArray(NettyClient[]::new))
                 .build();
@@ -308,26 +310,43 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
         new Thread(() -> tournament.run(gameType)).start();
     }
 
-    public void endTournament(IntegerScoreSystem score) {
+    public void endTournament(List<IntegerScoreSystem> systems) {
+        if (systems.isEmpty()) return;
 
-        List<String> u = new ArrayList<>();
-        List<Integer> s = new ArrayList<>();
+        Map<String, List<ImmutablePair<String, Integer>>> combined = new HashMap<>();
 
-        for (var entry : score.getScore().entrySet()) {
-            u.add(entry.getKey().name());
-            s.add(entry.getValue());
+        for (var system : systems) {
+            for (var player : system.getScore().keySet()) {
+                combined.putIfAbsent(player.name(), new ArrayList<>());
+                combined.get(player.name()).addLast(new ImmutablePair<>(system.scoreName(), system.getScore().get(player)));
+            }
+        }
+
+        List<String> names = new ArrayList<>();
+        List<String> systemNames = new ArrayList<>();
+        List<List<Integer>> scores = new ArrayList<>();
+
+        for (var player : combined.entrySet()) {
+            names.addLast(player.getKey());
+            scores.addLast(new ArrayList<>());
+            for (var system : player.getValue()) {
+                if (!systemNames.contains(system.getLeft())) systemNames.addLast(system.getLeft());
+                scores.getLast().addLast(system.getRight());
+            }
         }
 
         Gson gson = new Gson();
 
-        String users = gson.toJson(u);
-        String scores = gson.toJson(s);
+        String namesJson = gson.toJson(names);
+        String systemNamesJson = gson.toJson(systemNames);
+        String scoresJson = gson.toJson(scores);
 
         String msg = String.format(
-                "SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORES: %s, TOURNAMENT: 1}",
+                "SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORETYPES: %s, SCORES: %s, TOURNAMENT: 1}",
                 "none", // TODO gametype
-                users,
-                scores
+                namesJson,
+                systemNamesJson,
+                scoresJson
         );
 
         for (var user : onlineUsers()) {

framework/src/main/java/org/toop/framework/networking/server/tournaments/AsyncTournamentRunner.java

@@ -16,16 +16,14 @@ public class AsyncTournamentRunner implements TournamentRunner {
     public void run(
             MatchExecutor matchRunner,
             MatchMaker matchMaker,
-            IntegerScoreSystem scoreSystem,
+            List<IntegerScoreSystem> scoreSystems,
             ResultBroadcaster<IntegerScoreSystem> broadcaster,
             Duration turnTime,
             String gameType
     ) {
 
-        ExecutorService matchExecutor =
-                Executors.newFixedThreadPool(
-                        Runtime.getRuntime().availableProcessors()
-                );
+        ExecutorService matchExecutor = Executors.newVirtualThreadPerTaskExecutor();
+        ExecutorService scoringExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
 
         Queue<TournamentMatch> pendingMatches = new ConcurrentLinkedQueue<>();
         matchMaker.forEach(pendingMatches::add);
@@ -56,7 +54,11 @@ public class AsyncTournamentRunner implements TournamentRunner {
                             CompletableFuture.runAsync(() -> {
                                 try {
                                     GameResultFuture game = matchRunner.submit(gameType, turnTime, a, b);
-                                    scoreSystem.result(match, game.result().join());
+
+                                    CompletableFuture.runAsync(
+                                            () -> scoreSystems.forEach(s -> s.result(match, game.result().join())),
+                                            scoringExecutor
+                                    ).join();
                                 } finally {
                                     a.clearGame();
                                     b.clearGame();
@@ -73,7 +75,7 @@ public class AsyncTournamentRunner implements TournamentRunner {
                 Thread.sleep(10); // Safety
             }
 
-            broadcaster.broadcast(scoreSystem);
+            broadcaster.broadcast(scoreSystems);
 
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();

framework/src/main/java/org/toop/framework/networking/server/tournaments/BasicTournamentRunner.java

@@ -6,6 +6,7 @@ import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
 import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
 
 import java.time.Duration;
+import java.util.List;
 import java.util.concurrent.*;
 
 public class BasicTournamentRunner implements TournamentRunner {
@@ -13,7 +14,7 @@ public class BasicTournamentRunner implements TournamentRunner {
     public void run(
             MatchExecutor matchExecutor,
             MatchMaker matchMaker,
-            IntegerScoreSystem scoreSystem,
+            List<IntegerScoreSystem> scoreSystems,
             ResultBroadcaster<IntegerScoreSystem> broadcaster,
             Duration turnTime,
             String gameType
@@ -24,13 +25,13 @@ public class BasicTournamentRunner implements TournamentRunner {
                 for (TournamentMatch match : matchMaker) {
                     // Play game and await the results
                     GameResultFuture game = matchExecutor.submit(gameType, turnTime, match.getClient0(), match.getClient1());
-                    scoreSystem.result(match, game.result().join());
+                    scoreSystems.forEach(e -> e.result(match, game.result().join()));
 
                     match.getClient0().clearGame();
                     match.getClient1().clearGame();
                 }
 
-                broadcaster.broadcast(scoreSystem);
+                broadcaster.broadcast(scoreSystems);
             });
         } finally {
             threadPool.shutdown();

framework/src/main/java/org/toop/framework/networking/server/tournaments/ResultBroadcaster.java

@@ -2,7 +2,9 @@ package org.toop.framework.networking.server.tournaments;
 
 import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
 
+import java.util.List;
+
 @FunctionalInterface
 public interface ResultBroadcaster<T extends ScoreSystem<?, ?, ?>> {
-    void broadcast(T scoreSystem);
+    void broadcast(List<T> scoreSystem);
 }

framework/src/main/java/org/toop/framework/networking/server/tournaments/Tournament.java

@@ -4,45 +4,52 @@ import org.toop.framework.networking.server.MatchExecutor;
 import org.toop.framework.networking.server.client.NettyClient;
 import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
 import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
+import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
 
 import java.time.Duration;
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
 import java.util.Objects;
 
 public class Tournament {
 
     private final MatchExecutor matchExecutor;
-    private final IntegerScoreSystem scoreSystem;
+    private final List<IntegerScoreSystem> scoreSystems;
     private final TournamentRunner tournamentRunner;
     private final MatchMaker matchMaker;
     private final ResultBroadcaster<IntegerScoreSystem> broadcaster;
     private final NettyClient[] players;
     private final Duration turnTime;
+    private final Shuffler shuffler;
 
     private Tournament(Tournament.Builder builder) {
         matchExecutor = builder.matchExecutor;
-        scoreSystem = builder.scoreSystem;
+        scoreSystems = builder.scoreSystems;
         tournamentRunner = builder.tournamentRunner;
         matchMaker = builder.matchMaker;
         broadcaster = builder.broadcaster;
         players = builder.players;
         turnTime = builder.turnTime;
+        shuffler = builder.shuffler;
     }
 
-    public void run(String gameType) throws IllegalArgumentException {
+    public void run(String gameType) {
 
         Arrays.stream(players).forEach(e -> {
             matchMaker.addPlayer(e);
-            scoreSystem.addPlayer(e);
+            scoreSystems.forEach(k -> k.addPlayer(e));
         });
 
-        tournamentRunner.run(matchExecutor, matchMaker, scoreSystem, broadcaster, turnTime, gameType);
+        if (shuffler != null) matchMaker.shuffle(shuffler);
+
+        tournamentRunner.run(matchExecutor, matchMaker, scoreSystems, broadcaster, turnTime, gameType);
 
     }
 
     public static class Builder {
         private MatchExecutor matchExecutor;
-        private IntegerScoreSystem scoreSystem;
+        private List<IntegerScoreSystem> scoreSystems = new ArrayList<>();
         private TournamentRunner tournamentRunner;
         private MatchMaker matchMaker;
         private ResultBroadcaster<IntegerScoreSystem> broadcaster;
@@ -50,14 +57,15 @@ public class Tournament {
         private NettyClient[] observors;
         private NettyClient[] admins;
         private Duration turnTime = Duration.ofSeconds(10);
+        private Shuffler shuffler;
 
         public Builder matchExecutor(MatchExecutor matchExecutor) {
             this.matchExecutor = matchExecutor;
             return this;
         }
 
-        public Builder scoreSystem(IntegerScoreSystem scoreSystem) {
-            this.scoreSystem = scoreSystem;
+        public Builder addScoreSystem(IntegerScoreSystem scoreSystem) {
+            this.scoreSystems.addLast(scoreSystem);
             return this;
         }
 
@@ -96,9 +104,13 @@ public class Tournament {
             return this;
         }
 
+        public Builder addMatchShuffler(Shuffler shuffler) {
+            this.shuffler = shuffler;
+            return this;
+        }
+
         public Tournament build() {
             Objects.requireNonNull(matchExecutor, "matchExecutor");
-            Objects.requireNonNull(scoreSystem, "scoreSystem");
             Objects.requireNonNull(tournamentRunner, "tournamentRunner");
             Objects.requireNonNull(matchMaker, "matchMaker");
             Objects.requireNonNull(broadcaster, "resultBroadcaster"); // TODO is not always necessary and needs to be more generic, not just at the end

framework/src/main/java/org/toop/framework/networking/server/tournaments/TournamentRunner.java

@@ -5,8 +5,9 @@ import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
 import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
 
 import java.time.Duration;
+import java.util.List;
 
 public interface TournamentRunner {
-    void run(MatchExecutor matchExecutor, MatchMaker matchMaker, IntegerScoreSystem scoreSystem,
+    void run(MatchExecutor matchExecutor, MatchMaker matchMaker, List<IntegerScoreSystem> scoreSystems,
              ResultBroadcaster<IntegerScoreSystem> broadcaster, Duration turnTime, String gameType);
 }

framework/src/main/java/org/toop/framework/networking/server/tournaments/matchmakers/DoubleRoundRobinMatchMaker.java

@@ -0,0 +1,81 @@
+package org.toop.framework.networking.server.tournaments.matchmakers;
+
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.tournaments.TournamentMatch;
+import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.NoSuchElementException;
+
+public class DoubleRoundRobinMatchMaker implements MatchMaker {
+
+    private final List<NettyClient> players = new ArrayList<>();
+
+    public DoubleRoundRobinMatchMaker() {} // TODO let user decide store type
+
+    @Override
+    public void addPlayer(NettyClient player) {
+        players.addLast(player);
+    }
+
+    @Override
+    public void shuffle(Shuffler shuffler) {
+        if (players.size() < 2) return;
+        shuffler.shuffle(players);
+    }
+
+    @Override
+    public List<NettyClient> getPlayers() {
+        return players;
+    }
+
+    @Override
+    public Iterator<TournamentMatch> iterator() {
+        return new Iterator<>() {
+
+            private int i = 0;
+            private int j = 1;
+            private boolean reverse = false;
+
+            @Override
+            public boolean hasNext() {
+                return players.size() > 1
+                        && i < players.size() - 1
+                        && j < players.size();
+            }
+
+            @Override
+            public TournamentMatch next() {
+                if (!hasNext()) {
+                    throw new NoSuchElementException();
+                }
+
+                NettyClient home = players.get(i);
+                NettyClient away = players.get(j);
+
+                TournamentMatch match = reverse ? new TournamentMatch(away, home) : new TournamentMatch(home, away);
+
+                advance();
+                return match;
+            }
+
+            private void advance() {
+                j++;
+                if (j >= players.size()) {
+                    i++;
+                    j = i + 1;
+
+                    if (i >= players.size() - 1) {
+                        if (!reverse) {
+                            reverse = true;
+                            i = 0;
+                            j = 1;
+                        }
+                    }
+                }
+            }
+        };
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/tournaments/matchmakers/RoundRobinMatchMaker.java

@@ -37,7 +37,6 @@ public class RoundRobinMatchMaker implements MatchMaker {
 
             private int i = 0;
             private int j = 1;
-            private boolean reverse = false;
 
             @Override
             public boolean hasNext() {
@@ -55,26 +54,13 @@ public class RoundRobinMatchMaker implements MatchMaker {
                 NettyClient home = players.get(i);
                 NettyClient away = players.get(j);
 
-                TournamentMatch match = reverse ? new TournamentMatch(away, home) : new TournamentMatch(home, away);
-
-                advance();
-                return match;
-            }
-
-            private void advance() {
                 j++;
                 if (j >= players.size()) {
                     i++;
                     j = i + 1;
+                }
 
-                    if (i >= players.size() - 1) {
-                        if (!reverse) {
-                            reverse = true;
-                            i = 0;
-                            j = 1;
-                        }
-                    }
-                }
+                return new TournamentMatch(home, away);
             }
         };
     }

framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/DrawCountScoreSystem.java

@@ -0,0 +1,43 @@
+package org.toop.framework.networking.server.tournaments.scoresystems;
+
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.tournaments.TournamentMatch;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class DrawCountScoreSystem implements IntegerScoreSystem {
+
+    private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
+    private final int INIT_SCORE = 0;
+    private final int WIN_POINTS = 1;
+
+    public DrawCountScoreSystem() {} // TODO let user decide store type
+
+    @Override
+    public String scoreName() {
+        return "draws";
+    }
+
+    @Override
+    public void addPlayer(NettyClient user) {
+        scores.putIfAbsent(user, INIT_SCORE);
+    }
+
+    @Override
+    public void result(TournamentMatch match, Integer result) {
+        switch (result) {
+            case 0, 1 -> {}
+            case -1 -> {
+                scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
+                scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
+            }
+            default -> throw new IllegalArgumentException("Unknown result: " + result);
+        }
+    }
+
+    @Override
+    public Map<NettyClient, Integer> getScore() {
+        return scores;
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/LoseCountScoreSystem.java

@@ -0,0 +1,41 @@
+package org.toop.framework.networking.server.tournaments.scoresystems;
+
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.tournaments.TournamentMatch;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class LoseCountScoreSystem implements IntegerScoreSystem {
+
+    private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
+    private final int INIT_SCORE = 0;
+    private final int WIN_POINTS = 1;
+
+    public LoseCountScoreSystem() {} // TODO let user decide store type
+
+    @Override
+    public String scoreName() {
+        return "loses";
+    }
+
+    @Override
+    public void addPlayer(NettyClient user) {
+        scores.putIfAbsent(user, INIT_SCORE);
+    }
+
+    @Override
+    public void result(TournamentMatch match, Integer result) {
+        switch (result) {
+            case 0 -> scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
+            case 1 -> scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
+            case -1 -> {} // Draw
+            default -> throw new IllegalArgumentException("Unknown result: " + result);
+        }
+    }
+
+    @Override
+    public Map<NettyClient, Integer> getScore() {
+        return scores;
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/MatchCountScoreSystem.java

@@ -0,0 +1,37 @@
+package org.toop.framework.networking.server.tournaments.scoresystems;
+
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.tournaments.TournamentMatch;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class MatchCountScoreSystem implements IntegerScoreSystem {
+
+    private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
+    private final int INIT_SCORE = 0;
+    private final int WIN_POINTS = 1;
+
+    public MatchCountScoreSystem() {} // TODO let user decide store type
+
+    @Override
+    public String scoreName() {
+        return "matches";
+    }
+
+    @Override
+    public void addPlayer(NettyClient user) {
+        scores.putIfAbsent(user, INIT_SCORE);
+    }
+
+    @Override
+    public void result(TournamentMatch match, Integer result) {
+        scores.merge(match.getClient0(), WIN_POINTS, Integer::sum);
+        scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
+    }
+
+    @Override
+    public Map<NettyClient, Integer> getScore() {
+        return scores;
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/ScoreSystem.java

@@ -3,6 +3,7 @@ package org.toop.framework.networking.server.tournaments.scoresystems;
 import java.util.Map;
 
 public interface ScoreSystem<MATCHTYPE, SCORETYPE, USERTYPE> {
+    String scoreName();
     void addPlayer(USERTYPE user);
     void result(MATCHTYPE match, SCORETYPE result);
     Map<USERTYPE, SCORETYPE> getScore();

framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/WinCountScoreSystem.java

@@ -3,17 +3,21 @@ package org.toop.framework.networking.server.tournaments.scoresystems;
 import org.toop.framework.networking.server.client.NettyClient;
 import org.toop.framework.networking.server.tournaments.TournamentMatch;
 
-import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 
-public class BasicScoreSystem implements IntegerScoreSystem {
+public class WinCountScoreSystem implements IntegerScoreSystem {
 
     private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
     private final int INIT_SCORE = 0;
     private final int WIN_POINTS = 1;
 
-    public BasicScoreSystem() {} // TODO let user decide store type
+    public WinCountScoreSystem() {} // TODO let user decide store type
+
+    @Override
+    public String scoreName() {
+        return "wins";
+    }
 
     @Override
     public void addPlayer(NettyClient user) {