update mcts

# Conflicts:
#	app/src/main/java/org/toop/Main.java
#	app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java
#	framework/src/main/java/org/toop/framework/game/BitboardGame.java
#	framework/src/main/java/org/toop/framework/game/games/reversi/BitboardReversi.java
#	game/src/main/java/org/toop/game/players/ArtificialPlayer.java
#	game/src/main/java/org/toop/game/players/ai/MCTSAI.java
#	game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI1.java
#	game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI2.java
#	game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI3.java
#	game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI4.java

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

@@ -1,53 +1,68 @@
 package org.toop;
 
 import org.toop.app.App;
+import org.toop.framework.game.games.reversi.BitboardReversi;
+import org.toop.framework.game.players.ArtificialPlayer;
+import org.toop.game.players.ai.MCTSAI;
+import org.toop.game.players.ai.RandomAI;
+import org.toop.game.players.ai.mcts.MCTSAI1;
+import org.toop.game.players.ai.mcts.MCTSAI2;
+import org.toop.game.players.ai.mcts.MCTSAI3;
+import org.toop.game.players.ai.mcts.MCTSAI4;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 public final class Main {
     static void main(String[] args) {
 		App.run(args);
-		// testMCTS(10);
+
+		// final ExecutorService executor = Executors.newFixedThreadPool(1);
+		// executor.execute(() -> testAIs(25));
     }
 
-	// Voor onderzoek
-	// private static void testMCTS(int games) {
-	// 	var random = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), "Random AI");
-	// 	var v1 = new ArtificialPlayer<>(new MCTSAI<BitboardTicTacToe>(10), "MCTS V1 AI");
-	// 	var v2 = new ArtificialPlayer<>(new MCTSAI2<BitboardTicTacToe>(10), "MCTS V2 AI");
-	// 	var v2_2 = new ArtificialPlayer<>(new MCTSAI2<BitboardTicTacToe>(100), "MCTS V2_2 AI");
-	// 	var v3 = new ArtificialPlayer<>(new MCTSAI3<BitboardTicTacToe>(10), "MCTS V3 AI");
+	private static void testAIs(int games) {
+		var versions = new ArtificialPlayer[5];
+		versions[0] = new ArtificialPlayer(new RandomAI(), "Random AI");
+		versions[1] = new ArtificialPlayer(new MCTSAI1(1000), "MCTS V1 AI");
+		versions[2] = new ArtificialPlayer(new MCTSAI2(1000), "MCTS V2 AI");
+		versions[3] = new ArtificialPlayer(new MCTSAI3(10, 10), "MCTS V3 AI");
+		versions[4] = new ArtificialPlayer(new MCTSAI4(10, 10), "MCTS V4 AI");
 
-	// 	testAI(games, new Player[]{ v1, v2 });
-	// 	// testAI(games, new Player[]{ v1, v3 });
+		for (int i = 0; i < versions.length; i++) {
+			for (int j = i + 1; j < versions.length; j++) {
+				final int playerIndex1 = i % versions.length;
+				final int playerIndex2 = j % versions.length;
 
-	// 	// testAI(games, new Player[]{ random, v3 });
-	// 	// testAI(games, new Player[]{ v2, v3 });
-	// 	testAI(games, new Player[]{ v2, v3 });
-	// 	// testAI(games, new Player[]{ v3, v2 });
-	// }
+				testAIVSAI(games, new ArtificialPlayer[] { versions[playerIndex1], versions[playerIndex2]});
+			}
+		}
+	}
 
-	// private static void testAI(int games, Player<BitboardReversi>[] ais) {
-	// 	int wins = 0;
-	// 	int ties = 0;
+	private static void testAIVSAI(int games, ArtificialPlayer[] ais) {
+		int wins = 0;
+		int ties = 0;
 
-	// 	for (int i = 0; i < games; i++) {
-	// 		final BitboardReversi match = new BitboardReversi(ais);
+		for (int i = 0; i < games; i++) {
+			final BitboardReversi match = new BitboardReversi();
+			match.init(ais);
 
-	// 		while (!match.isTerminal()) {
-	// 			final int currentAI = match.getCurrentTurn();
-	// 			final long move = ais[currentAI].getMove(match);
+			while (!match.isTerminal()) {
+				final int currentAI = match.getCurrentTurn();
+				final long move = ais[currentAI].getMove(match);
 
-	// 			match.play(move);
-	// 		}
+				match.play(move);
+			}
 
-	// 		if (match.getWinner() < 0) {
-	// 			ties++;
-	// 			continue;
-	// 		}
+			if (match.getWinner() < 0) {
+				ties++;
+				continue;
+			}
 
-	// 		wins += match.getWinner() == 0? 1 : 0;
-	// 	}
+			wins += match.getWinner() == 0? 1 : 0;
+		}
 
-	// 	System.out.printf("Out of %d games, %s won %d -- tied %d -- lost %d, games against %s\n", games, ais[0].getName(), wins, ties, games - wins - ties, ais[1].getName());
-	// 	System.out.printf("Average win rate was: %.2f\n\n", wins / (float)games);
-	// }
-}
+		System.out.printf("Out of %d games, %s won %d -- tied %d -- lost %d, games against %s\n", games, ais[0].getName(), wins, ties, games - wins - ties, ais[1].getName());
+		System.out.printf("Average win rate was: %.2f\n\n", wins / (float)games);
+	}
+}

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;
@@ -19,7 +20,7 @@ import org.toop.framework.networking.connection.clients.TournamentNetworkingClie
 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.mcts.MCTSAI3;
 import org.toop.local.AppContext;
 
 import java.util.Arrays;
@@ -208,7 +209,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(1000, Runtime.getRuntime().availableProcessors()), user);
             players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
 
             switch (type) {
@@ -244,7 +246,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) {

app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java

@@ -2,9 +2,13 @@ package org.toop.app.canvas;
 
 import javafx.scene.paint.Color;
 import org.toop.app.App;
+import org.toop.framework.game.games.reversi.BitboardReversi;
+import org.toop.framework.game.players.LocalPlayer;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 public class ReversiBitCanvas extends BitGameCanvas {
+    private TurnBasedGame gameCopy;
+    private int previousCell;
     public ReversiBitCanvas() {
         super(Color.GRAY, new Color(0f, 0.4f, 0.2f, 1f), (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3, 8, 8, 5, true);
         canvas.setOnMouseMoved(event -> {
@@ -20,6 +24,9 @@ public class ReversiBitCanvas extends BitGameCanvas {
                     break;
                 }
             }
+            if (hovered != null) {
+                checkHoverDots(hovered, cellId);
+            }
         });
     }
 
@@ -31,9 +38,31 @@ public class ReversiBitCanvas extends BitGameCanvas {
 
     @Override
     public void redraw(TurnBasedGame gameCopy) {
+        this.gameCopy = gameCopy;
         clearAll();
         long[] board = gameCopy.getBoard();
         loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
         loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
     }
+
+    public void drawLegalDots(TurnBasedGame gameCopy){
+        long legal = gameCopy.getLegalMoves();
+        loopOverBoard(legal, (i) -> drawInnerDot(gameCopy.getCurrentTurn()==0?new Color(1f,1f,1f,0.65f) :new Color(0f,0f,0f,0.65f), i,false));
+    }
+
+    private void checkHoverDots(BitGameCanvas.Cell hovered, int cellId){
+        if (previousCell == cellId){
+            return;
+        }
+        long backflips = ((BitboardReversi)gameCopy).getFlips(1L << previousCell);
+        loopOverBoard(backflips, (i) -> drawInnerDot(gameCopy.getCurrentTurn()==1?Color.WHITE:Color.BLACK, i,true));
+        previousCell = cellId;
+        if (gameCopy.getPlayer(gameCopy.getCurrentTurn()) instanceof LocalPlayer) {
+            long legal = gameCopy.getLegalMoves();
+            if ((legal & (1L << cellId)) != 0) {
+                long flips = ((BitboardReversi) gameCopy).getFlips(1L << cellId);
+                loopOverBoard(flips, (i) -> drawInnerDot(gameCopy.getCurrentTurn() == 0 ? Color.WHITE : Color.BLACK, i, false));
+            }
+        }
+    }
 }

app/src/main/java/org/toop/app/gameControllers/GenericGameController.java

@@ -5,6 +5,7 @@ import javafx.geometry.Pos;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.app.canvas.GameCanvas;
+import org.toop.app.canvas.ReversiBitCanvas;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.view.GameView;
 import org.toop.framework.eventbus.EventFlow;
@@ -153,6 +154,12 @@ public class GenericGameController implements GameController {
 
     @Override
     public void updateUI() {
-        canvas.redraw(game.deepCopy());
+        TurnBasedGame gameCopy = game.deepCopy();
+        canvas.redraw(gameCopy);
+        String gameType = game.getClass().getSimpleName().replace("Bitboard","");
+        gameView.nextPlayer(true, getCurrentPlayer().getName(), game.getPlayer(1-getCurrentPlayerIndex()).getName(),gameType);
+        if (getCurrentPlayer() instanceof LocalPlayer && gameType.equals("Reversi")){
+            ((ReversiBitCanvas)canvas).drawLegalDots(gameCopy);
+        }
     }
 }

app/src/main/java/org/toop/app/widget/view/GameView.java

@@ -6,6 +6,8 @@ import javafx.scene.text.Font;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.ViewWidget;
 import org.toop.app.widget.popup.GameOverPopup;
+
+import java.util.Objects;
 import java.util.function.Consumer;
 import javafx.application.Platform;
 import javafx.geometry.Pos;
@@ -94,7 +96,7 @@ public final class GameView extends ViewWidget {
 		}
 	}
 
-	public void nextPlayer(boolean isMe, String currentPlayer, String currentMove, String nextPlayer, char GameType) {
+	public void nextPlayer(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
 		Platform.runLater(() -> {
             if (!(hasSet)) {
                 playerHeader.setText(currentPlayer + " vs. " + nextPlayer);
@@ -112,8 +114,8 @@ public final class GameView extends ViewWidget {
 		new GameOverPopup(iWon, winner).show(Pos.CENTER);
 	}
 
-    private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, char GameType) {
-        if (GameType == 'T') {
+    private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
+        if (Objects.equals(GameType, "TicTacToe")) {
             if (isMe) {
                 player1Header.setText("X: " + currentPlayer);
                 player2Header.setText("O: " + nextPlayer);
@@ -124,7 +126,7 @@ public final class GameView extends ViewWidget {
             }
             setPlayerInfoTTT();
         }
-        else if (GameType == 'R') {
+        else if (Objects.equals(GameType, "Reversi")) {
             if (isMe) {
                 player1Header.setText(currentPlayer);
                 player2Header.setText(nextPlayer);
@@ -172,8 +174,8 @@ public final class GameView extends ViewWidget {
 
         player1Icon.setRadius(player1Header.fontProperty().map(Font::getSize).getValue());
         player2Icon.setRadius(player2Header.fontProperty().map(Font::getSize).getValue());
-        player1Icon.setFill(Color.BLACK);
-        player2Icon.setFill(Color.WHITE);
+        player1Icon.setFill(Color.WHITE);
+        player2Icon.setFill(Color.BLACK);
         add(Pos.TOP_RIGHT, playerInfo);
     }
 }

app/src/main/java/org/toop/app/widget/view/LocalMultiplayerView.java

@@ -4,6 +4,7 @@ import javafx.application.Platform;
 import org.toop.app.GameInformation;
 import org.toop.app.gameControllers.ReversiBitController;
 import org.toop.app.gameControllers.TicTacToeBitController;
+import org.toop.framework.game.players.LocalPlayer;
 import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.framework.game.players.ArtificialPlayer;
@@ -12,11 +13,10 @@ import org.toop.app.widget.complex.PlayerInfoWidget;
 import org.toop.app.widget.complex.ViewWidget;
 import org.toop.app.widget.popup.ErrorPopup;
 import org.toop.app.widget.tutorial.*;
-import org.toop.framework.game.players.LocalPlayer;
-import org.toop.game.players.ai.MCTSAI;
-import org.toop.game.players.ai.MCTSAI2;
-import org.toop.game.players.ai.MCTSAI3;
 import org.toop.game.players.ai.MiniMaxAI;
+import org.toop.game.players.ai.mcts.MCTSAI1;
+import org.toop.game.players.ai.mcts.MCTSAI3;
+import org.toop.game.players.ai.mcts.MCTSAI4;
 import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
@@ -54,7 +54,7 @@ public class LocalMultiplayerView extends ViewWidget {
                     if (information.players[0].isHuman) {
                         players[0] = new LocalPlayer(information.players[0].name);
                     } else {
-                        players[0] = new ArtificialPlayer(new MCTSAI(100), "MCTS AI");
+                        players[0] = new ArtificialPlayer(new MCTSAI1(100), "MCTS AI");
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer(information.players[1].name);
@@ -83,12 +83,12 @@ public class LocalMultiplayerView extends ViewWidget {
                         players[0] = new LocalPlayer(information.players[0].name);
                     } else {
 						// players[0] = new ArtificialPlayer(new RandomAI<BitboardReversi>(), "Random AI");
-						players[0] = new ArtificialPlayer(new MCTSAI3(50), "MCTS V3 AI");
+						players[0] = new ArtificialPlayer(new MCTSAI4(500, 4), "MCTS V4 AI");
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer(information.players[1].name);
                     } else {
-						players[1] = new ArtificialPlayer(new MCTSAI2(50), "MCTS V2 AI");
+						players[1] = new ArtificialPlayer(new MCTSAI1(500), "MCTS V1 AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(

app/src/main/java/org/toop/app/widget/view/ServerView.java

@@ -45,7 +45,7 @@ public final class ServerView extends ViewWidget {
 	private void setupLayout(String userName) {
 		var playerHeader = Primitive.header(user, false);
 
-        if (userName.equals("host")) {
+        if (userName.equals("host")) { // TODO is fragile
             var tournamentButton = Primitive.hbox(
                     gameListTour,
                     Primitive.button(
@@ -77,7 +77,10 @@ public final class ServerView extends ViewWidget {
             add(Pos.CENTER, playerListSection);
 
             var disconnectButton = Primitive.button(
-                    "disconnect", () -> transitionPrevious(), false);
+                    "disconnect",
+					this::transitionPrevious,
+					false
+			);
 
             add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
         }

framework/src/main/java/org/toop/framework/game/BitboardGame.java

@@ -6,6 +6,7 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
 import java.util.Arrays;
+import java.util.concurrent.atomic.AtomicInteger;
 
 // There is AI performance to be gained by getting rid of non-primitives and thus speeding up deepCopy
 public abstract class BitboardGame implements TurnBasedGame {

framework/src/main/java/org/toop/framework/game/gameThreads/ServerThreadBehaviour.java

@@ -1,31 +1,39 @@
 package org.toop.framework.game.gameThreads;
 
-import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.AbstractThreadBehaviour;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.framework.gameFramework.view.GUIEvents;
 import org.toop.framework.utils.ImmutablePair;
 import org.toop.framework.utils.Pair;
 
+import java.time.Duration;
+import java.util.concurrent.*;
 import java.util.function.Consumer;
 
-import static org.toop.framework.gameFramework.GameState.TURN_SKIPPED;
-import static org.toop.framework.gameFramework.GameState.WIN;
-
 public class ServerThreadBehaviour extends AbstractThreadBehaviour implements Runnable {
     private final Consumer<ImmutablePair<String, Integer>> onPlayerMove;
     private final Consumer<Pair<GameState, Integer>> onGameEnd;
+
+    private final ExecutorService moveExecutor = Executors.newSingleThreadExecutor();
+
+    private final Duration timeOut;
     /**
      * Creates a new base behaviour for the specified game.
      *
      * @param game the turn-based game to control
      */
-    public ServerThreadBehaviour(TurnBasedGame game, Consumer<ImmutablePair<String, Integer>> onPlayerMove, Consumer<Pair<GameState, Integer>> onGameEnd) {
+    public ServerThreadBehaviour(
+            TurnBasedGame game,
+            Consumer<ImmutablePair<String,
+                    Integer>> onPlayerMove,
+            Consumer<Pair<GameState, Integer>> onGameEnd,
+            Duration timeOut
+    ) {
         this.onPlayerMove = onPlayerMove;
         this.onGameEnd = onGameEnd;
+        this.timeOut = timeOut;
         super(game);
     }
 
@@ -59,23 +67,42 @@ public class ServerThreadBehaviour extends AbstractThreadBehaviour implements Ru
     public void run() {
         while (isRunning.get()) {
             Player currentPlayer = game.getPlayer(game.getCurrentTurn());
-            long move = currentPlayer.getMove(game.deepCopy());
-            PlayResult result = game.play(move);
 
-            GameState state = result.state();
-            notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(move)));
+            Future<Long> move = moveExecutor.submit(() -> currentPlayer.getMove(game.deepCopy()));
 
-            switch (state) {
-                case WIN, DRAW -> {
-                    isRunning.set(false);
-                    notifyGameEnd(new ImmutablePair<>(state, game.getWinner()));
-                }
-                case NORMAL, TURN_SKIPPED -> { /* continue normally */ }
-                default -> {
-                    logger.error("Unexpected state {}", state);
-                    isRunning.set(false);
-                    throw new RuntimeException("Unknown state: " + state);
+            PlayResult result;
+            try {
+                long moveResult = move.get(timeOut.toMillis(), TimeUnit.MILLISECONDS);
+                result = game.play(moveResult);
+
+                GameState state = result.state();
+                notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(moveResult)));
+
+                switch (state) {
+                    case WIN, DRAW -> {
+                        isRunning.set(false);
+                        moveExecutor.shutdown();
+                        notifyGameEnd(new ImmutablePair<>(state, game.getWinner()));
+                    }
+                    case NORMAL, TURN_SKIPPED -> { /* continue normally */ }
+                    default -> {
+                        logger.error("Unexpected state {}", state);
+                        isRunning.set(false);
+                        moveExecutor.shutdown();
+                        throw new RuntimeException("Unknown state: " + state);
+                    }
                 }
+
+            } catch (InterruptedException | ExecutionException e) {
+                isRunning.set(false);
+                notifyGameEnd(new ImmutablePair<>(GameState.DRAW, 0));
+                moveExecutor.shutdown();
+                return;
+            } catch (TimeoutException e) {
+                isRunning.set(false);
+                notifyGameEnd(new ImmutablePair<>(GameState.WIN, 1+game.getWinner()%2));
+                moveExecutor.shutdown();
+                return;
             }
         }
     }

framework/src/main/java/org/toop/framework/game/games/reversi/BitboardReversi.java

@@ -321,8 +321,51 @@ public class BitboardReversi extends BitboardGame {
         else if (blackCount > whiteCount){
             return 0;
         }
-        else{
+        else {
             return 1;
         }
     }
+
+	@Override
+	public float rateMove(long move) {
+		final long corners = 0x8100000000000081L;
+
+		if ((move & corners) != 0L) {
+			return 0.4f;
+		}
+
+		final long xSquares = 0x0042000000004200L;
+
+		if ((move & xSquares) != 0) {
+			return -0.4f;
+		}
+
+		final long cSquares = 0x4281000000008142L;
+
+		if ((move & cSquares) != 0) {
+			return -0.1f;
+		}
+
+		return 0.0f;
+	}
+
+	@Override
+	public long heuristicMove(long legalMoves) {
+		long bestMove = 0L;
+		float bestMoveRate = Float.NEGATIVE_INFINITY;
+
+		while (legalMoves != 0L) {
+			final long move = legalMoves & -legalMoves;
+			final float moveRate = rateMove(move);
+
+			if (moveRate > bestMoveRate) {
+				bestMove = move;
+				bestMoveRate = moveRate;
+			}
+
+			legalMoves &= ~move;
+		}
+
+		return bestMove;
+	}
 }

framework/src/main/java/org/toop/framework/game/games/tictactoe/BitboardTicTacToe.java

@@ -110,4 +110,14 @@ public class BitboardTicTacToe extends BitboardGame {
     public BitboardTicTacToe deepCopy() {
         return new BitboardTicTacToe(this);
     }
+
+	@Override
+	public float rateMove(long move) {
+		return 0.0f;
+	}
+
+	@Override
+	public long heuristicMove(long legalMoves) {
+		return legalMoves;
+	}
 }

framework/src/main/java/org/toop/framework/game/players/ArtificialPlayer.java

@@ -57,4 +57,8 @@ public class ArtificialPlayer extends AbstractPlayer {
     public ArtificialPlayer deepCopy() {
         return new ArtificialPlayer(this);
     }
+
+    public AI getAi() {
+        return ai;
+    }
 }

framework/src/main/java/org/toop/framework/game/players/ServerPlayer.java

@@ -29,13 +29,8 @@ public class ServerPlayer extends AbstractPlayer {
     @Override
     public long determineMove(TurnBasedGame game) {
         lastMove = new CompletableFuture<>();
-        System.out.println("Sending yourturn");
-        client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}\n");
-        try {
-            return lastMove.get();
-        } catch (InterruptedException | ExecutionException e) {
-            e.printStackTrace();
-            return 0;
-        }
+
+        client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}");
+        return lastMove.join();
     }
 }

framework/src/main/java/org/toop/framework/gameFramework/model/game/TurnBasedGame.java

@@ -13,4 +13,7 @@ public interface TurnBasedGame extends DeepCopyable<TurnBasedGame> {
     PlayResult play(long move);
 	PlayResult getState();
 	boolean isTerminal();
+
+	float rateMove(long move);
+	long heuristicMove(long legalMoves);
 }

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(","))
-                    .map(String::trim)
-                    .map(Integer::parseInt)
-                    .toArray(Integer[]::new);
+            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)
+                    )
+                    .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/GameServer.java

@@ -2,11 +2,12 @@ package org.toop.framework.networking.server;
 
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
+import java.time.Duration;
 import java.util.List;
 import java.util.concurrent.CompletableFuture;
 
 public interface GameServer<GAMETYPE, CLIENT, CHALLENGEIDTYPE> {
-    GameResultFuture startGame(String gameType, CLIENT... clients);
+    GameResultFuture startGame(String gameType, Duration turnTime, CLIENT... clients);
 
     void addClient(CLIENT client);
     void removeClient(CLIENT client);

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

@@ -0,0 +1,10 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.networking.server.client.NettyClient;
+
+import java.time.Duration;
+
+@FunctionalInterface
+public interface MatchExecutor {
+    GameResultFuture submit(String gameType, Duration turnTime, NettyClient... clients);
+}

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

@@ -5,7 +5,7 @@ import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.networking.server.client.NettyClient;
 
-import java.util.ArrayList;
+import java.time.Duration;
 import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
 
@@ -19,12 +19,13 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
 
     private final CompletableFuture<Integer> resultFuture;
 
-    public OnlineTurnBasedGame(NettyClient[] admins, TurnBasedGame game, CompletableFuture<Integer> resultFuture, NettyClient... clients) {
+    public OnlineTurnBasedGame(NettyClient[] admins, TurnBasedGame game, CompletableFuture<Integer> resultFuture, Duration timeOut, NettyClient... clients) {
         this.game = game;
         this.gameThread = new ServerThreadBehaviour(
                 game,
                 (pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()),
-                (pair) -> notifyGameEnd(pair.getLeft(), pair.getRight())
+                (pair) -> notifyGameEnd(pair.getLeft(), pair.getRight()),
+                timeOut
         );
         this.resultFuture = resultFuture;
         this.clients = clients;
@@ -42,17 +43,15 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
 
     private void notifyGameEnd(GameState state, int winner) {
         if (state == GameState.DRAW) {
-            Arrays.stream(admins).forEach(a -> a.send(
-                String.format("SVR GAME END")
-            ));
+            Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
 
             for (NettyClient client : clients) {
-                client.send(String.format("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}"));
+                client.send("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
             }
         } else {
             Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
-            clients[winner].send(String.format("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}"));
-            clients[(winner+1)%2].send(String.format("SVR GAME LOSS {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}"));
+            clients[winner].send("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
+            clients[(winner+1)%2].send("SVR GAME LOSS {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
         }
 
         // Remove game from clients

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.shufflers.RandomShuffle;
+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.*;
@@ -111,7 +110,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
     public void acceptChallenge(Long challengeId) {
         for (var challenge : gameChallenges) {
             if (challenge.id() == challengeId) {
-                startGame(challenge.acceptChallenge(), challenge.getUsers());
+                startGame(challenge.acceptChallenge(), Duration.ofSeconds(10), challenge.getUsers());
                 break;
             }
         }
@@ -133,7 +132,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
     }
 
     @Override
-    public GameResultFuture startGame(String gameType, NettyClient... clients) {
+    public GameResultFuture startGame(String gameType, Duration turnTime, NettyClient... clients) {
         if (!gameTypesStore.all().containsKey(gameType)) return null;
 
         try {
@@ -146,6 +145,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
                     getAdmins().toArray(NettyClient[]::new),
                     gameTypesStore.create(gameType),
                     gameResult,
+                    turnTime,
                     clients
             );
 
@@ -167,6 +167,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
                     clients[0].name(),
                     gameType,
                     clients[0].name()));
+
             game.start();
             return grfReturn;
         } catch (Exception e) {
@@ -250,7 +251,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
                 userNames.remove(first);
                 userNames.remove(second);
 
-                startGame(key, null, getUser(userLeft), getUser(userRight));
+                startGame(key, Duration.ofSeconds(10), getUser(userLeft), getUser(userRight));
             }
         }
     }
@@ -294,47 +295,60 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
         var tournamentUsers = new ArrayList<>(onlineUsers());
         tournamentUsers.removeIf(admins::contains);
 
-        var matchMaker = new RoundRobinMatchMaker(tournamentUsers);
-        if (shuffle) {
-            matchMaker.shuffle(new RandomShuffle()); // Remove if not wanting to shuffle
-        }
+        Tournament tournament = new Tournament.Builder()
+                .matchExecutor(this::startGame)
+                .tournamentRunner(new AsyncTournamentRunner())
+                .matchMaker(new DoubleRoundRobinMatchMaker())
+                .addScoreSystem(new MatchCountScoreSystem())
+                .addScoreSystem(new WinCountScoreSystem())
+                .addScoreSystem(new DrawCountScoreSystem())
+                .addScoreSystem(new LoseCountScoreSystem())
+                .resultBroadcaster(this::endTournament)
+                .turnTimeout(Duration.ofSeconds(10))
+                .addPlayers(tournamentUsers.toArray(NettyClient[]::new))
+                .addAdmins(admins.toArray(NettyClient[]::new))
+                .build();
 
-        Tournament tournament = new BasicTournament(new TournamentBuilder(
-                this,
-                new AsyncTournamentRunner(),
-                matchMaker,
-                new BasicScoreSystem(tournamentUsers)
-        ));
-
-        try {
-            new Thread(() -> tournament.run(gameType)).start();
-        } catch (IllegalArgumentException e) {
-            admins.forEach(c -> c.send("ERR not enough clients to start a tournament"));
-        } catch (RuntimeException e) {
-            admins.forEach(c -> c.send("ERR no matches could be created to start a tournament with"));
-        }
+        new Thread(() -> tournament.run(gameType)).start();
     }
 
-    public void endTournament(Map<NettyClient, Integer> score, String gameType) {
+    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.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}",
-                gameType,
-                users,
-                scores
+                "SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORETYPES: %s, SCORES: %s, TOURNAMENT: 1}",
+                "none", // TODO gametype
+                namesJson,
+                systemNamesJson,
+                scoresJson
         );
 
         for (var user : onlineUsers()) {

framework/src/main/java/org/toop/framework/networking/server/client/NettyClient.java

@@ -56,7 +56,6 @@ public class NettyClient implements Client<OnlineTurnBasedGame, ServerPlayer> {
 
     @Override
     public void send(String message) {
-        IO.println(message);
         ctx.channel().writeAndFlush(message + "\r\n");
     }
 

framework/src/main/java/org/toop/framework/networking/server/handlers/MessageHandler.java

@@ -1,12 +1,9 @@
 package org.toop.framework.networking.server.handlers;
 
-import org.toop.framework.game.players.ServerPlayer;
-import org.toop.framework.networking.server.OnlineTurnBasedGame;
 import org.toop.framework.networking.server.Server;
 import org.toop.framework.networking.server.client.Client;
 import org.toop.framework.networking.server.client.NettyClient;
 import org.toop.framework.networking.server.parsing.ParsedMessage;
-import org.toop.framework.networking.server.tournaments.*;
 import org.toop.framework.utils.Utils;
 
 public class MessageHandler implements Handler<ParsedMessage> {
@@ -111,8 +108,11 @@ public class MessageHandler implements Handler<ParsedMessage> {
     private void handleMove(ParsedMessage p, NettyClient client) {
         if(!hasArgs(p.args())) return;
 
+        var player = client.player();
+        if (player == null) return;
+
         // TODO check if not number
-        client.player().setMove(1L << Integer.parseInt(p.args()[0]));
+        player.setMove(1L << Integer.parseInt(p.args()[0]));
     }
 
     private void handleTournament(ParsedMessage p, NettyClient client) {

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

@@ -1,11 +1,12 @@
 package org.toop.framework.networking.server.tournaments;
 
 import org.toop.framework.networking.server.GameResultFuture;
-import org.toop.framework.networking.server.Server;
+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.ScoreSystem;
+import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
 
+import java.time.Duration;
 import java.util.*;
 import java.util.concurrent.*;
 
@@ -13,16 +14,16 @@ public class AsyncTournamentRunner implements TournamentRunner {
 
     @Override
     public void run(
-            Server server,
+            MatchExecutor matchRunner,
             MatchMaker matchMaker,
-            ScoreSystem 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);
@@ -52,8 +53,12 @@ public class AsyncTournamentRunner implements TournamentRunner {
                     CompletableFuture<Void> f =
                             CompletableFuture.runAsync(() -> {
                                 try {
-                                    GameResultFuture game = server.startGame(gameType, a, b);
-                                    scoreSystem.matchEndAwait(game);
+                                    GameResultFuture game = matchRunner.submit(gameType, turnTime, a, b);
+
+                                    CompletableFuture.runAsync(
+                                            () -> scoreSystems.forEach(s -> s.result(match, game.result().join())),
+                                            scoringExecutor
+                                    ).join();
                                 } finally {
                                     a.clearGame();
                                     b.clearGame();
@@ -70,7 +75,7 @@ public class AsyncTournamentRunner implements TournamentRunner {
                 Thread.sleep(10); // Safety
             }
 
-            server.endTournament(scoreSystem.getScore(), gameType);
+            broadcaster.broadcast(scoreSystems);
 
         } catch (InterruptedException e) {
             Thread.currentThread().interrupt();

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

@@ -1,29 +0,0 @@
-package org.toop.framework.networking.server.tournaments;
-
-import org.toop.framework.networking.server.Server;
-import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
-import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
-
-public class BasicTournament implements Tournament {
-    private final Server server;
-
-    private final ScoreSystem scoreSystem;
-    private final TournamentRunner tournamentRunner;
-    private final MatchMaker matchMaker;
-
-    public BasicTournament(TournamentBuilder builder) {
-        server = builder.server;
-        scoreSystem = builder.scoreSystem;
-        tournamentRunner = builder.tournamentRunner;
-        matchMaker = builder.matchMaker;
-    }
-
-    @Override
-    public boolean run(String gameType) throws RuntimeException {
-        if (server.gameTypes().stream().noneMatch(e -> e.equalsIgnoreCase(gameType))) return false;
-
-        tournamentRunner.run(server, matchMaker, scoreSystem, gameType);
-
-        return true;
-    }
-}

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

@@ -1,28 +1,37 @@
 package org.toop.framework.networking.server.tournaments;
 
 import org.toop.framework.networking.server.GameResultFuture;
-import org.toop.framework.networking.server.Server;
+import org.toop.framework.networking.server.MatchExecutor;
 import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
-import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
+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 {
     @Override
-    public void run(Server server, MatchMaker matchMaker, ScoreSystem scoreSystem, String gameType) {
+    public void run(
+            MatchExecutor matchExecutor,
+            MatchMaker matchMaker,
+            List<IntegerScoreSystem> scoreSystems,
+            ResultBroadcaster<IntegerScoreSystem> broadcaster,
+            Duration turnTime,
+            String gameType
+    ) {
         ExecutorService threadPool = Executors.newSingleThreadExecutor();
         try {
             threadPool.execute(() -> {
                 for (TournamentMatch match : matchMaker) {
                     // Play game and await the results
-                    GameResultFuture game = server.startGame(gameType, match.getClient0(), match.getClient1());
-                    scoreSystem.matchEndAwait(game);
+                    GameResultFuture game = matchExecutor.submit(gameType, turnTime, match.getClient0(), match.getClient1());
+                    scoreSystems.forEach(e -> e.result(match, game.result().join()));
 
                     match.getClient0().clearGame();
                     match.getClient1().clearGame();
                 }
 
-                server.endTournament(scoreSystem.getScore(), gameType);
+                broadcaster.broadcast(scoreSystems);
             });
         } finally {
             threadPool.shutdown();

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

@@ -0,0 +1,10 @@
+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(List<T> scoreSystem);
+}

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

@@ -1,11 +1,121 @@
 package org.toop.framework.networking.server.tournaments;
 
+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.util.HashMap;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
 
-public interface Tournament {
-//    void init(TournamentBuilder builder);
-    boolean run(String gameType);
-//    HashMap<NettyClient, Integer> end();
+public class Tournament {
+
+    private final MatchExecutor matchExecutor;
+    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;
+        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) {
+
+        Arrays.stream(players).forEach(e -> {
+            matchMaker.addPlayer(e);
+            scoreSystems.forEach(k -> k.addPlayer(e));
+        });
+
+        if (shuffler != null) matchMaker.shuffle(shuffler);
+
+        tournamentRunner.run(matchExecutor, matchMaker, scoreSystems, broadcaster, turnTime, gameType);
+
+    }
+
+    public static class Builder {
+        private MatchExecutor matchExecutor;
+        private List<IntegerScoreSystem> scoreSystems = new ArrayList<>();
+        private TournamentRunner tournamentRunner;
+        private MatchMaker matchMaker;
+        private ResultBroadcaster<IntegerScoreSystem> broadcaster;
+        private NettyClient[] players;
+        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 addScoreSystem(IntegerScoreSystem scoreSystem) {
+            this.scoreSystems.addLast(scoreSystem);
+            return this;
+        }
+
+        public Builder tournamentRunner(TournamentRunner tournamentRunner) {
+            this.tournamentRunner = tournamentRunner;
+            return this;
+        }
+
+        public Builder matchMaker(MatchMaker matchMaker) {
+            this.matchMaker = matchMaker;
+            return this;
+        }
+
+        public Builder resultBroadcaster(ResultBroadcaster<IntegerScoreSystem> broadcaster) {
+            this.broadcaster = broadcaster;
+            return this;
+        }
+
+        public Builder addPlayers(NettyClient[] players) {
+            this.players = players;
+            return this;
+        }
+
+        public Builder addObservers(NettyClient[] observors) { // TODO
+            this.observors = observors;
+            return this;
+        }
+
+        public Builder addAdmins(NettyClient[] admins) { // TODO
+            this.admins = admins;
+            return this;
+        }
+
+        public Builder turnTimeout(Duration turnTime) {
+            this.turnTime = turnTime;
+            return this;
+        }
+
+        public Builder addMatchShuffler(Shuffler shuffler) {
+            this.shuffler = shuffler;
+            return this;
+        }
+
+        public Tournament build() {
+            Objects.requireNonNull(matchExecutor, "matchExecutor");
+            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
+            Objects.requireNonNull(players, "players");
+            return new Tournament(this);
+        }
+    }
 }

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

@@ -1,24 +0,0 @@
-package org.toop.framework.networking.server.tournaments;
-
-import org.toop.framework.networking.server.Server;
-import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
-import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
-
-public class TournamentBuilder {
-    public Server server;
-    public ScoreSystem scoreSystem;
-    public TournamentRunner tournamentRunner;
-    public MatchMaker matchMaker;
-
-    public TournamentBuilder(
-            Server server,
-            TournamentRunner tournamentRunner,
-            MatchMaker matchMaker,
-            ScoreSystem scoreSystem
-    ) {
-        this.server = server;
-        this.tournamentRunner = tournamentRunner;
-        this.matchMaker = matchMaker;
-        this.scoreSystem = scoreSystem;
-    }
-}

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

@@ -8,11 +8,11 @@ public class TournamentMatch extends ImmutablePair<NettyClient, NettyClient> {
         super(a, b);
     }
 
-    NettyClient getClient0() {
+    public NettyClient getClient0() {
         return getLeft();
     }
 
-    NettyClient getClient1() {
+    public NettyClient getClient1() {
         return getRight();
     }
 }

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

@@ -1,9 +1,13 @@
 package org.toop.framework.networking.server.tournaments;
 
-import org.toop.framework.networking.server.Server;
+import org.toop.framework.networking.server.MatchExecutor;
 import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
-import org.toop.framework.networking.server.tournaments.scoresystems.ScoreSystem;
+import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
+
+import java.time.Duration;
+import java.util.List;
 
 public interface TournamentRunner {
-    void run(Server server, MatchMaker matchMaker, ScoreSystem scoreSystem, String gameType);
+    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/MatchMaker.java

@@ -7,6 +7,7 @@ import org.toop.framework.networking.server.tournaments.shufflers.Shuffler;
 import java.util.List;
 
 public interface MatchMaker extends Iterable<TournamentMatch> {
+    void addPlayer(NettyClient player);
     List<NettyClient> getPlayers();
     void shuffle(Shuffler shuffler);
 }

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

@@ -4,20 +4,25 @@ 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 RoundRobinMatchMaker implements MatchMaker {
 
-    private final List<NettyClient> players;
+    private final List<NettyClient> players = new ArrayList<>();
 
-    public RoundRobinMatchMaker(List<NettyClient> players) {
-        this.players = players;
+    public RoundRobinMatchMaker() {} // 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);
     }
 
@@ -32,7 +37,6 @@ public class RoundRobinMatchMaker implements MatchMaker {
 
             private int i = 0;
             private int j = 1;
-            private boolean reverse = false;
 
             @Override
             public boolean hasNext() {
@@ -50,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/BasicScoreSystem.java

@@ -1,42 +0,0 @@
-package org.toop.framework.networking.server.tournaments.scoresystems;
-
-import org.toop.framework.networking.server.GameResultFuture;
-import org.toop.framework.networking.server.client.NettyClient;
-
-import java.util.List;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-
-public class BasicScoreSystem implements ScoreSystem {
-
-    private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
-
-    public BasicScoreSystem(List<NettyClient> store) {
-        for (NettyClient c : store) {
-            scores.putIfAbsent(c, getInitScore());
-        }
-    }
-
-    @Override
-    public void matchEndAwait(GameResultFuture result) {
-
-        if (result.game().users().length < 2) return;
-
-        switch (result.result().join()) {
-            case 0 -> givePoints(result.game().users()[0]);
-            case 1 -> givePoints(result.game().users()[1]);
-            case -1 -> {} // Draw
-            default -> {}
-        }
-    }
-
-    private void givePoints(NettyClient client) {
-        int clientScore = scores.get(client);
-        scores.put(client, clientScore + getWinPointAmount());
-    }
-
-    @Override
-    public Map<NettyClient, Integer> getScore() {
-        return scores;
-    }
-}

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/IntegerScoreSystem.java

@@ -0,0 +1,6 @@
+package org.toop.framework.networking.server.tournaments.scoresystems;
+
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.tournaments.TournamentMatch;
+
+public interface IntegerScoreSystem extends ScoreSystem<TournamentMatch, Integer, NettyClient> {}

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

@@ -1,19 +1,10 @@
 package org.toop.framework.networking.server.tournaments.scoresystems;
 
-import org.toop.framework.networking.server.GameResultFuture;
-import org.toop.framework.networking.server.client.NettyClient;
-import org.toop.framework.networking.server.tournaments.TournamentMatch;
-
 import java.util.Map;
 
-public interface ScoreSystem {
-    void matchEndAwait(GameResultFuture result);
-    Map<NettyClient, Integer> getScore();
-
-    default int getWinPointAmount() {
-        return 1;
-    }
-    default int getInitScore() {
-        return 0;
-    }
+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

@@ -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 WinCountScoreSystem implements IntegerScoreSystem {
+
+    private final Map<NettyClient, Integer> scores = new ConcurrentHashMap<>();
+    private final int INIT_SCORE = 0;
+    private final int WIN_POINTS = 1;
+
+    public WinCountScoreSystem() {} // TODO let user decide store type
+
+    @Override
+    public String scoreName() {
+        return "wins";
+    }
+
+    @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.getClient0(), WIN_POINTS, Integer::sum);
+            case 1 -> scores.merge(match.getClient1(), WIN_POINTS, Integer::sum);
+            case -1 -> {} // Draw
+            default -> throw new IllegalArgumentException("Unknown result: " + result);
+        }
+    }
+
+    @Override
+    public Map<NettyClient, Integer> getScore() {
+        return scores;
+    }
+}

game/src/main/java/org/toop/game/players/ai/MCTSAI.java

@@ -1,193 +1,288 @@
 package org.toop.game.players.ai;
 
-import org.toop.framework.gameFramework.GameState;
-import org.toop.framework.gameFramework.model.game.PlayResult;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractAI;
 
 import java.util.Random;
 
-public class MCTSAI extends AbstractAI {
-	private static class Node {
+public abstract class MCTSAI extends AbstractAI {
+	protected static class Node {
 		public TurnBasedGame state;
+
 		public long move;
+		public long unexpandedMoves;
 
 		public Node parent;
-
-		public int expanded;
 		public Node[] children;
 
-		public int visits;
 		public float value;
+		public int visits;
+
+		public float heuristic;
+
+		public float solved;
+
+		public Node(TurnBasedGame state, Node parent, long move) {
+			final long legalMoves = state.getLegalMoves();
 
-		public Node(TurnBasedGame state, long move, Node parent) {
 			this.state = state;
+
 			this.move = move;
+			this.unexpandedMoves = legalMoves;
 
 			this.parent = parent;
+			this.children = new Node[Long.bitCount(legalMoves)];
 
-			this.expanded = 0;
-			this.children = new Node[Long.bitCount(state.getLegalMoves())];
-
-			this.visits = 0;
 			this.value = 0.0f;
+			this.visits = 0;
+
+			this.heuristic = state.rateMove(move);
+
+			this.solved = Float.NaN;
 		}
 
 		public Node(TurnBasedGame state) {
-			this(state, 0L, null);
+			this(state, null, 0L);
+		}
+
+		public int getExpanded() {
+			return children.length - Long.bitCount(unexpandedMoves);
 		}
 
 		public boolean isFullyExpanded() {
-			return expanded >= children.length;
+			return unexpandedMoves == 0L;
 		}
 
-		float calculateUCT() {
-			float exploitation = visits <= 0? 0 : value / visits;
-			float exploration = 1.41f * (float)(Math.sqrt(Math.log(visits) / visits));
+		public float calculateUCT(int parentVisits) {
+			if (visits == 0) {
+				return Float.POSITIVE_INFINITY;
+			}
 
-			return exploitation + exploration;
+			final float exploitation = value / visits;
+			final float exploration = (float)(Math.sqrt(Math.log(parentVisits) / visits));
+			final float bias = heuristic * 10.0f / (visits + 1);
+
+			return exploitation + exploration + bias;
 		}
 
 		public Node bestUCTChild() {
-			int bestChildIndex = -1;
-			float bestScore = Float.NEGATIVE_INFINITY;
+			final int expanded = getExpanded();
+
+			Node highestUCTChild = null;
+			float highestUCT = Float.NEGATIVE_INFINITY;
 
 			for (int i = 0; i < expanded; i++) {
-				final float score = calculateUCT();
+				final float childUCT = children[i].calculateUCT(visits);
 
-				if (score > bestScore) {
-					bestChildIndex = i;
-					bestScore = score;
+				if (childUCT > highestUCT) {
+					highestUCTChild = children[i];
+					highestUCT = childUCT;
 				}
 			}
 
-			return bestChildIndex >= 0? children[bestChildIndex] : this;
+			return highestUCTChild;
 		}
 	}
 
-	private final int milliseconds;
+	protected static final ThreadLocal<Random> random = ThreadLocal.withInitial(Random::new);
+
+	protected final int milliseconds;
+
+	protected int lastIterations;
 
 	public MCTSAI(int milliseconds) {
 		this.milliseconds = milliseconds;
+
+		this.lastIterations = 0;
 	}
 
 	public MCTSAI(MCTSAI other) {
 		this.milliseconds = other.milliseconds;
+
+		this.lastIterations = other.lastIterations;
 	}
 
-	@Override
-	public MCTSAI deepCopy() {
-		return new MCTSAI(this);
+	public int getLastIterations() {
+		return lastIterations;
 	}
 
-	@Override
-	public long getMove(TurnBasedGame game) {
-		Node root = new Node(game.deepCopy());
-
-		long endTime = System.currentTimeMillis() + milliseconds;
-
-		while (System.currentTimeMillis() <= endTime) {
-			Node node = selection(root);
-			long legalMoves = node.state.getLegalMoves();
-
-			if (legalMoves != 0) {
-				node = expansion(node, legalMoves);
-			}
-
-			float result = 0.0f;
-
-			if (node.state.getLegalMoves() != 0) {
-				result = simulation(node.state, game.getCurrentTurn());
-			}
-
-			backPropagation(node, result);
+	protected Node selection(Node root) {
+		// while (Float.isNaN(root.solved) && root.isFullyExpanded() && !root.state.isTerminal()) {
+		while (root.isFullyExpanded() && !root.state.isTerminal()) {
+			root = root.bestUCTChild();
 		}
 
-		int mostVisitedIndex = -1;
-		int mostVisits = -1;
-
-		for (int i = 0; i < root.expanded; i++) {
-			if (root.children[i].visits > mostVisits) {
-				mostVisitedIndex = i;
-				mostVisits = root.children[i].visits;
-			}
-		}
-
-		return mostVisitedIndex != -1? root.children[mostVisitedIndex].move : randomSetBit(game.getLegalMoves());
+		return root;
 	}
 
-	private Node selection(Node node) {
-		while (node.state.getLegalMoves() != 0L && node.isFullyExpanded()) {
-			node = node.bestUCTChild();
+	protected Node expansion(Node leaf) {
+		if (leaf.unexpandedMoves == 0L) {
+			return leaf;
 		}
 
-		return node;
+		final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
+
+		final TurnBasedGame copiedState = leaf.state.deepCopy();
+		copiedState.play(unexpandedMove);
+
+		final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
+
+		leaf.children[leaf.getExpanded()] = expandedChild;
+		leaf.unexpandedMoves &= ~unexpandedMove;
+
+		return expandedChild;
 	}
 
-	private Node expansion(Node node, long legalMoves) {
-		for (int i = 0; i < node.expanded; i++) {
-			legalMoves &= ~node.children[i].move;
+	protected float simulation(Node leaf) {
+		final TurnBasedGame copiedState = leaf.state.deepCopy();
+		final int playerIndex = 1 - copiedState.getCurrentTurn();
+
+		while (!copiedState.isTerminal()) {
+			final long legalMoves = copiedState.getLegalMoves();
+			final long randomMove = randomSetBit(legalMoves);
+
+			copiedState.play(randomMove);
 		}
 
-		if (legalMoves == 0L) {
-			return node;
+		if (copiedState.getWinner() == playerIndex) {
+			return 1.0f;
 		}
 
-		long move = randomSetBit(legalMoves);
-
-		TurnBasedGame copy = node.state.deepCopy();
-		copy.play(move);
-
-		Node newlyExpanded = new Node(copy, move, node);
-
-		node.children[node.expanded] = newlyExpanded;
-		node.expanded++;
-
-		return newlyExpanded;
-	}
-
-	private float simulation(TurnBasedGame state, int playerIndex) {
-		TurnBasedGame copy = state.deepCopy();
-		long legalMoves = copy.getLegalMoves();
-		PlayResult result = null;
-
-		while (legalMoves != 0) {
-			result = copy.play(randomSetBit(legalMoves));
-			legalMoves = copy.getLegalMoves();
-		}
-
-		if (result.state() == GameState.WIN) {
-			if (result.player() == playerIndex) {
-				return 1.0f;
-			}
-
+		if (copiedState.getWinner() >= 0) {
 			return -1.0f;
 		}
 
-		return -0.2f;
+		return 0.0f;
 	}
 
-	private void backPropagation(Node node, float value) {
-		while (node != null) {
-			node.visits++;
-			node.value += value;
-			node = node.parent;
+	protected void backPropagation(Node leaf, float value) {
+		while (leaf != null) {
+			leaf.value += value;
+			leaf.visits++;
+
+			if (Float.isNaN(leaf.solved)) {
+				updateSolvedStatus(leaf);
+			}
+
+			value = -value;
+			leaf = leaf.parent;
 		}
 	}
 
-	public static long randomSetBit(long value) {
-		Random random = new Random();
+	protected Node mostVisitedChild(Node root) {
+		final int expanded = root.getExpanded();
 
-		int count = Long.bitCount(value);
-		int target = random.nextInt(count);
+		Node mostVisitedChild = null;
+		int mostVisited = -1;
 
-		while (true) {
-			int bit = Long.numberOfTrailingZeros(value);
-			if (target == 0) {
-				return 1L << bit;
+		for (int i = 0; i < expanded; i++) {
+			if (root.children[i].visits > mostVisited) {
+				mostVisitedChild = root.children[i];
+				mostVisited = root.children[i].visits;
 			}
+		}
+
+		return mostVisitedChild;
+	}
+
+	protected Node findOrResetRoot(Node root, TurnBasedGame game) {
+		if (root == null) {
+			return new Node(game.deepCopy());
+		}
+
+		if (areStatesEqual(root.state.getBoard(), game.getBoard())) {
+			return root;
+		}
+
+		final int expanded = root.getExpanded();
+
+		for (int i = 0; i < expanded; i++) {
+			if (areStatesEqual(root.children[i].state.getBoard(), game.getBoard())) {
+				root.children[i].parent = null;
+				return root.children[i];
+			}
+		}
+
+		return new Node(game.deepCopy());
+	}
+
+	protected Node findChildByMove(Node root, long move) {
+		final int expanded = root.getExpanded();
+
+		for (int i = 0; i < expanded; i++) {
+			if (root.children[i].move == move) {
+				root.children[i].parent = null;
+				return root.children[i];
+			}
+		}
+
+		return null;
+	}
+
+	protected boolean areStatesEqual(long[] state1, long[] state2) {
+		if (state1.length != state2.length) {
+			return false;
+		}
+
+		for (int i = 0; i < state1.length; i++) {
+			if (state1[i] != state2[i]) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	protected long randomSetBit(long value) {
+		if (0L == value) {
+			return 0;
+		}
+
+		final int bitCount = Long.bitCount(value);
+		final int randomBitCount = random.get().nextInt(bitCount);
+
+		for (int i = 0; i < randomBitCount; i++) {
 			value &= value - 1;
-			target--;
+		}
+
+		return value & -value;
+	}
+
+	private void updateSolvedStatus(Node node) {
+		if (node.state.isTerminal()) {
+			final int winner = node.state.getWinner();
+			final int mover = 1 - node.state.getCurrentTurn();
+
+			node.solved = winner == mover? 1.0f : winner == -1? 0.0f : -1.0f;
+
+			return;
+		}
+
+		if (node.isFullyExpanded()) {
+			boolean allChildrenSolved = true;
+			boolean foundWinningMove = false;
+			boolean foundDrawMove = false;
+
+			for (final Node child : node.children) {
+				if (!Float.isNaN(child.solved)) {
+					if (child.solved == -1.0f) {
+						foundWinningMove = true;
+						break;
+					}
+
+					if (child.solved == 0.0f) {
+						foundDrawMove = true;
+					}
+				} else {
+					allChildrenSolved = false;
+				}
+			}
+
+			if (foundWinningMove) {
+				node.solved = 1.0f;
+			} else if (allChildrenSolved) {
+				node.solved = foundDrawMove? 0.0f : -1.0f;
+			}
 		}
 	}
 }

game/src/main/java/org/toop/game/players/ai/MCTSAI2.java

@@ -1,195 +0,0 @@
-package org.toop.game.players.ai;
-
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.gameFramework.model.player.AbstractAI;
-
-import java.util.Random;
-
-public class MCTSAI2 extends AbstractAI {
-	private static class Node {
-		public TurnBasedGame state;
-
-		public long move;
-		public long unexpandedMoves;
-
-		public Node parent;
-
-		public Node[] children;
-		public int expanded;
-
-		public float value;
-		public int visits;
-
-		public Node(TurnBasedGame state, Node parent, long move) {
-			final long legalMoves = state.getLegalMoves();
-
-			this.state = state;
-
-			this.move = move;
-			this.unexpandedMoves = legalMoves;
-
-			this.parent = parent;
-
-			this.children = new Node[Long.bitCount(legalMoves)];
-			this.expanded = 0;
-
-			this.value = 0.0f;
-			this.visits = 0;
-		}
-
-		public Node(TurnBasedGame state) {
-			this(state, null, 0L);
-		}
-
-		public boolean isFullyExpanded() {
-			return expanded == children.length;
-		}
-
-		public float calculateUCT(int parentVisits) {
-			final float exploitation = value / visits;
-			final float exploration = 1.41f * (float)(Math.sqrt(Math.log(parentVisits) / visits));
-
-			return exploitation + exploration;
-		}
-
-		public Node bestUCTChild() {
-			Node highestUCTChild = null;
-			float highestUCT = Float.NEGATIVE_INFINITY;
-
-			for (int i = 0; i < expanded; i++) {
-				final float childUCT = children[i].calculateUCT(visits);
-
-				if (childUCT > highestUCT) {
-					highestUCTChild = children[i];
-					highestUCT = childUCT;
-				}
-
-			}
-
-			return highestUCTChild;
-		}
-	}
-
-	private final Random random;
-	private final int milliseconds;
-
-	public MCTSAI2(int milliseconds) {
-		this.random = new Random();
-		this.milliseconds = milliseconds;
-	}
-
-	public MCTSAI2(MCTSAI2 other) {
-		this.random = other.random;
-		this.milliseconds = other.milliseconds;
-	}
-
-	@Override
-	public MCTSAI2 deepCopy() {
-		return new MCTSAI2(this);
-	}
-
-	@Override
-	public long getMove(TurnBasedGame game) {
-		final Node root = new Node(game, null, 0L);
-
-		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
-
-		while (System.nanoTime() < endTime) {
-			Node leaf = selection(root);
-			leaf = expansion(leaf);
-			final float value = simulation(leaf);
-			backPropagation(leaf, value);
-		}
-
-		final Node mostVisitedChild = mostVisitedChild(root);
-
-		return mostVisitedChild != null? mostVisitedChild.move : 0L;
-	}
-
-	private Node mostVisitedChild(Node root) {
-		Node mostVisitedChild = null;
-		int mostVisited = -1;
-
-		for (int i = 0; i < root.expanded; i++) {
-			if (root.children[i].visits > mostVisited) {
-				mostVisitedChild = root.children[i];
-				mostVisited = root.children[i].visits;
-			}
-		}
-
-		return mostVisitedChild;
-	}
-
-	private Node selection(Node root) {
-		while (root.isFullyExpanded() && !root.state.isTerminal()) {
-			root = root.bestUCTChild();
-		}
-
-		return root;
-	}
-
-	private Node expansion(Node leaf) {
-		if (leaf.unexpandedMoves == 0L) {
-			return leaf;
-		}
-
-		final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
-
-		final TurnBasedGame copiedState = leaf.state.deepCopy();
-		copiedState.play(unexpandedMove);
-
-		final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
-
-		leaf.children[leaf.expanded] = expandedChild;
-		leaf.expanded++;
-
-		leaf.unexpandedMoves &= ~unexpandedMove;
-
-		return expandedChild;
-	}
-
-	private float simulation(Node leaf) {
-		final TurnBasedGame copiedState = leaf.state.deepCopy();
-		final int playerIndex = 1 - copiedState.getCurrentTurn();
-
-		while (!copiedState.isTerminal()) {
-			final long legalMoves = copiedState.getLegalMoves();
-			final long randomMove = randomSetBit(legalMoves);
-
-			copiedState.play(randomMove);
-		}
-
-		if (copiedState.getWinner() == playerIndex) {
-			return 1.0f;
-		} else if (copiedState.getWinner() >= 0) {
-			return -1.0f;
-		}
-
-		return 0.0f;
-	}
-
-	private void backPropagation(Node leaf, float value) {
-		while (leaf != null) {
-			leaf.value += value;
-			leaf.visits++;
-
-			value = -value;
-			leaf = leaf.parent;
-		}
-	}
-
-	private long randomSetBit(long value) {
-		if (0L == value) {
-			return 0;
-		}
-
-		final int bitCount = Long.bitCount(value);
-		final int randomBitCount = random.nextInt(bitCount);
-
-		for (int i = 0; i < randomBitCount; i++) {
-			value &= value - 1;
-		}
-
-		return value & -value;
-	}
-}

game/src/main/java/org/toop/game/players/ai/MCTSAI3.java

@@ -1,258 +0,0 @@
-package org.toop.game.players.ai;
-
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.gameFramework.model.player.AbstractAI;
-
-import java.util.Random;
-
-public class MCTSAI3 extends AbstractAI {
-	private static class Node {
-		public TurnBasedGame state;
-
-		public long move;
-		public long unexpandedMoves;
-
-		public Node parent;
-
-		public Node[] children;
-		public int expanded;
-
-		public float value;
-		public int visits;
-
-		public Node(TurnBasedGame state, Node parent, long move) {
-			final long legalMoves = state.getLegalMoves();
-
-			this.state = state;
-
-			this.move = move;
-			this.unexpandedMoves = legalMoves;
-
-			this.parent = parent;
-
-			this.children = new Node[Long.bitCount(legalMoves)];
-			this.expanded = 0;
-
-			this.value = 0.0f;
-			this.visits = 0;
-		}
-
-		public Node(TurnBasedGame state) {
-			this(state, null, 0L);
-		}
-
-		public boolean isFullyExpanded() {
-			return expanded == children.length;
-		}
-
-		public float calculateUCT(int parentVisits) {
-			final float exploitation = value / visits;
-			final float exploration = 1.41f * (float)(Math.sqrt(Math.log(parentVisits) / visits));
-
-			return exploitation + exploration;
-		}
-
-		public Node bestUCTChild() {
-			Node highestUCTChild = null;
-			float highestUCT = Float.NEGATIVE_INFINITY;
-
-			for (int i = 0; i < expanded; i++) {
-				final float childUCT = children[i].calculateUCT(visits);
-
-				if (childUCT > highestUCT) {
-					highestUCTChild = children[i];
-					highestUCT = childUCT;
-				}
-
-			}
-
-			return highestUCTChild;
-		}
-	}
-
-	private final Random random;
-
-	private Node root;
-	private final int milliseconds;
-
-	public MCTSAI3(int milliseconds) {
-		this.random = new Random();
-
-		this.root = null;
-		this.milliseconds = milliseconds;
-	}
-
-	public MCTSAI3(MCTSAI3 other) {
-		this.random = other.random;
-
-		this.root = other.root;
-		this.milliseconds = other.milliseconds;
-	}
-
-	@Override
-	public MCTSAI3 deepCopy() {
-		return new MCTSAI3(this);
-	}
-
-	@Override
-	public long getMove(TurnBasedGame game) {
-		detectRoot(game);
-
-		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
-
-		while (System.nanoTime() < endTime) {
-			Node leaf = selection(root);
-			leaf = expansion(leaf);
-			final float value = simulation(leaf);
-			backPropagation(leaf, value);
-		}
-
-		final Node mostVisitedChild = mostVisitedChild(root);
-		final long move = mostVisitedChild != null? mostVisitedChild.move : 0L;
-
-		newRoot(move);
-
-		return move;
-	}
-
-	private Node mostVisitedChild(Node root) {
-		Node mostVisitedChild = null;
-		int mostVisited = -1;
-
-		for (int i = 0; i < root.expanded; i++) {
-			if (root.children[i].visits > mostVisited) {
-				mostVisitedChild = root.children[i];
-				mostVisited = root.children[i].visits;
-			}
-		}
-
-		return mostVisitedChild;
-	}
-
-	private void detectRoot(TurnBasedGame game) {
-		if (root == null) {
-			root = new Node(game.deepCopy());
-			return;
-		}
-
-		final long[] currentBoards = game.getBoard();
-		final long[] rootBoards = root.state.getBoard();
-
-		boolean detected = true;
-
-		for (int i = 0; i < rootBoards.length; i++) {
-			if (rootBoards[i] != currentBoards[i]) {
-				detected = false;
-				break;
-			}
-		}
-
-		if (detected) {
-			return;
-		}
-
-		for (int i = 0; i < root.expanded; i++) {
-			final Node child = root.children[i];
-
-			final long[] childBoards = child.state.getBoard();
-
-			detected = true;
-
-			for (int j = 0; j < childBoards.length; j++) {
-				if (childBoards[j] != currentBoards[j]) {
-					detected = false;
-					break;
-				}
-			}
-
-			if (detected) {
-				root = child;
-				return;
-			}
-		}
-
-		root = new Node(game.deepCopy());
-	}
-
-	private void newRoot(long move) {
-		for (final Node child : root.children) {
-			if (child.move == move) {
-				root = child;
-				break;
-			}
-		}
-	}
-
-	private Node selection(Node root) {
-		while (root.isFullyExpanded() && !root.state.isTerminal()) {
-			root = root.bestUCTChild();
-		}
-
-		return root;
-	}
-
-	private Node expansion(Node leaf) {
-		if (leaf.unexpandedMoves == 0L) {
-			return leaf;
-		}
-
-		final long unexpandedMove = leaf.unexpandedMoves & -leaf.unexpandedMoves;
-
-		final TurnBasedGame copiedState = leaf.state.deepCopy();
-		copiedState.play(unexpandedMove);
-
-		final Node expandedChild = new Node(copiedState, leaf, unexpandedMove);
-
-		leaf.children[leaf.expanded] = expandedChild;
-		leaf.expanded++;
-
-		leaf.unexpandedMoves &= ~unexpandedMove;
-
-		return expandedChild;
-	}
-
-	private float simulation(Node leaf) {
-		final TurnBasedGame copiedState = leaf.state.deepCopy();
-		final int playerIndex = 1 - copiedState.getCurrentTurn();
-
-		while (!copiedState.isTerminal()) {
-			final long legalMoves = copiedState.getLegalMoves();
-			final long randomMove = randomSetBit(legalMoves);
-
-			copiedState.play(randomMove);
-		}
-
-		if (copiedState.getWinner() == playerIndex) {
-			return 1.0f;
-		} else if (copiedState.getWinner() >= 0) {
-			return -1.0f;
-		}
-
-		return 0.0f;
-	}
-
-	private void backPropagation(Node leaf, float value) {
-		while (leaf != null) {
-			leaf.value += value;
-			leaf.visits++;
-
-			value = -value;
-			leaf = leaf.parent;
-		}
-	}
-
-	private long randomSetBit(long value) {
-		if (0L == value) {
-			return 0;
-		}
-
-		final int bitCount = Long.bitCount(value);
-		final int randomBitCount = random.nextInt(bitCount);
-
-		for (int i = 0; i < randomBitCount; i++) {
-			value &= value - 1;
-		}
-
-		return value & -value;
-	}
-}

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI1.java

@@ -0,0 +1,39 @@
+package org.toop.game.players.ai.mcts;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.game.players.ai.MCTSAI;
+
+public class MCTSAI1 extends MCTSAI {
+	public MCTSAI1(int milliseconds) {
+		super(milliseconds);
+	}
+
+	public MCTSAI1(MCTSAI1 other) {
+		super(other);
+	}
+
+	@Override
+	public MCTSAI1 deepCopy() {
+		return new MCTSAI1(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		final Node root = new Node(game, null, 0L);
+
+		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
+
+		// while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
+		while (System.nanoTime() < endTime) {
+			Node leaf = selection(root);
+			leaf = expansion(leaf);
+			final float value = simulation(leaf);
+			backPropagation(leaf, value);
+		}
+
+		lastIterations = root.visits;
+
+		final Node mostVisitedChild = mostVisitedChild(root);
+		return mostVisitedChild.move;
+	}
+}

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI2.java

@@ -0,0 +1,49 @@
+package org.toop.game.players.ai.mcts;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.game.players.ai.MCTSAI;
+
+public class MCTSAI2 extends MCTSAI {
+	private Node root;
+
+	public MCTSAI2(int milliseconds) {
+		super(milliseconds);
+
+		this.root = null;
+	}
+
+	public MCTSAI2(MCTSAI2 other) {
+		super(other);
+
+		this.root = other.root;
+	}
+
+	@Override
+	public MCTSAI2 deepCopy() {
+		return new MCTSAI2(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		root = findOrResetRoot(root, game);
+
+		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
+
+		// while (Float.isNaN(root.solved) && System.nanoTime() < endTime) {
+		while (System.nanoTime() < endTime) {
+			Node leaf = selection(root);
+			leaf = expansion(leaf);
+			final float value = simulation(leaf);
+			backPropagation(leaf, value);
+		}
+
+		lastIterations = root.visits;
+
+		final Node mostVisitedChild = mostVisitedChild(root);
+		final long move = mostVisitedChild.move;
+
+		root = findChildByMove(root, move);
+
+		return move;
+	}
+}

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI3.java

@@ -0,0 +1,92 @@
+package org.toop.game.players.ai.mcts;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.game.players.ai.MCTSAI;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class MCTSAI3 extends MCTSAI {
+	private final int threads;
+
+	public MCTSAI3(int milliseconds, int threads) {
+		super(milliseconds);
+
+		this.threads = threads;
+	}
+
+	public MCTSAI3(MCTSAI3 other) {
+		super(other);
+
+		this.threads = other.threads;
+	}
+
+	@Override
+	public MCTSAI3 deepCopy() {
+		return new MCTSAI3(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		final ExecutorService pool = Executors.newFixedThreadPool(threads);
+		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
+
+		final List<Callable<Node>> tasks = new ArrayList<>();
+
+		for (int i = 0; i < threads; i++) {
+			tasks.add(() -> {
+				final Node localRoot = new Node(game.deepCopy());
+
+				// while (Float.isNaN(localRoot.solved) && System.nanoTime() < endTime) {
+				while (System.nanoTime() < endTime) {
+					Node leaf = selection(localRoot);
+					leaf = expansion(leaf);
+					final float value = simulation(leaf);
+					backPropagation(leaf, value);
+				}
+
+				return localRoot;
+			});
+		}
+
+		try {
+			final List<Future<Node>> results = pool.invokeAll(tasks);
+
+			pool.shutdown();
+
+			final Node root = new Node(game.deepCopy());
+
+			for (int i = 0; i < root.children.length; i++) {
+				expansion(root);
+			}
+
+			for (final Future<Node> result : results) {
+				final Node localRoot = result.get();
+
+				for (final Node localChild : localRoot.children) {
+					for (int i = 0; i < root.children.length; i++) {
+						if (localChild.move == root.children[i].move) {
+							root.children[i].visits += localChild.visits;
+							root.visits += localChild.visits;
+							break;
+						}
+					}
+				}
+			}
+
+			lastIterations = root.visits;
+
+			final Node mostVisitedChild = mostVisitedChild(root);
+			return mostVisitedChild.move;
+		} catch (Exception _) {
+			lastIterations = 0;
+
+			final long legalMoves = game.getLegalMoves();
+			return randomSetBit(legalMoves);
+		}
+	}
+}

game/src/main/java/org/toop/game/players/ai/mcts/MCTSAI4.java

@@ -0,0 +1,107 @@
+package org.toop.game.players.ai.mcts;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.game.players.ai.MCTSAI;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+
+public class MCTSAI4 extends MCTSAI {
+	private final int threads;
+	private final Node[] threadRoots;
+
+	public MCTSAI4(int milliseconds, int threads) {
+		super(milliseconds);
+
+		this.threads = threads;
+		this.threadRoots = new Node[threads];
+	}
+
+	public MCTSAI4(MCTSAI4 other) {
+		super(other);
+
+		this.threads = other.threads;
+		this.threadRoots = other.threadRoots;
+	}
+
+	@Override
+	public MCTSAI4 deepCopy() {
+		return new MCTSAI4(this);
+	}
+
+	@Override
+	public long getMove(TurnBasedGame game) {
+		for (int i = 0; i < threads; i++) {
+			threadRoots[i] = findOrResetRoot(threadRoots[i], game);
+		}
+
+		final ExecutorService pool = Executors.newFixedThreadPool(threads);
+		final long endTime = System.nanoTime() + milliseconds * 1_000_000L;
+
+		final List<Callable<Node>> tasks = new ArrayList<>();
+
+		for (int i = 0; i < threads; i++) {
+			final int threadIndex = i;
+
+			tasks.add(() -> {
+				final Node localRoot = threadRoots[threadIndex];
+
+				// while (Float.isNaN(localRoot.solved) && System.nanoTime() < endTime) {
+				while (System.nanoTime() < endTime) {
+					Node leaf = selection(localRoot);
+					leaf = expansion(leaf);
+					final float value = simulation(leaf);
+					backPropagation(leaf, value);
+				}
+
+				return localRoot;
+			});
+		}
+
+		try {
+			final List<Future<Node>> results = pool.invokeAll(tasks);
+
+			pool.shutdown();
+
+			final Node root = new Node(game.deepCopy());
+
+			for (int i = 0; i < root.children.length; i++) {
+				expansion(root);
+			}
+
+			for (final Future<Node> result : results) {
+				final Node localRoot = result.get();
+
+				for (final Node localChild : localRoot.children) {
+					for (int i = 0; i < root.children.length; i++) {
+						if (localChild.move == root.children[i].move) {
+							root.children[i].visits += localChild.visits;
+							root.visits += localChild.visits;
+							break;
+						}
+					}
+				}
+			}
+
+			lastIterations = root.visits;
+
+			final Node mostVisitedChild = mostVisitedChild(root);
+			final long move = mostVisitedChild.move;
+
+			for (int i = 0; i < threads; i++) {
+				threadRoots[i] = findChildByMove(threadRoots[i], move);
+			}
+
+			return move;
+		} catch (Exception _) {
+			lastIterations = 0;
+
+			final long legalMoves = game.getLegalMoves();
+			return randomSetBit(legalMoves);
+		}
+	}
+}