Merge branch 'Development' into 289-server

This reverts commit e2132b549d, reversing
changes made to 9aefcb9b7b.

.idea/inspectionProfiles/Project_Default.xml

@@ -2,7 +2,7 @@
   <profile version="1.0">
     <option name="myName" value="Project Default" />
     <inspection_tool class="AutoCloseableResource" enabled="true" level="WARNING" enabled_by_default="true">
-      <option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,java.lang.foreign.Arena,ofAuto,java.lang.foreign.Arena,global,org.toop.framework.audio.AudioPlayer,play,java.util.Map,remove,java.util.concurrent.Executors,newSingleThreadScheduledExecutor" />
+      <option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,java.lang.foreign.Arena,ofAuto,java.lang.foreign.Arena,global,org.toop.framework.audio.AudioPlayer,play,java.util.Map,remove,java.util.concurrent.Executors,newSingleThreadScheduledExecutor|newFixedThreadPool|newSingleThreadExecutor" />
     </inspection_tool>
     <inspection_tool class="WriteOnlyObject" enabled="false" level="WARNING" enabled_by_default="false" />
   </profile>

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

@@ -4,6 +4,50 @@ import org.toop.app.App;
 
 public final class Main {
     static void main(String[] args) {
-        App.run(args);
+		App.run(args);
+		// testMCTS(10);
     }
+
+	// 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");
+
+	// 	testAI(games, new Player[]{ v1, v2 });
+	// 	// testAI(games, new Player[]{ v1, v3 });
+
+	// 	// testAI(games, new Player[]{ random, v3 });
+	// 	// testAI(games, new Player[]{ v2, v3 });
+	// 	testAI(games, new Player[]{ v2, v3 });
+	// 	// testAI(games, new Player[]{ v3, v2 });
+	// }
+
+	// private static void testAI(int games, Player<BitboardReversi>[] ais) {
+	// 	int wins = 0;
+	// 	int ties = 0;
+
+	// 	for (int i = 0; i < games; i++) {
+	// 		final BitboardReversi match = new BitboardReversi(ais);
+
+	// 		while (!match.isTerminal()) {
+	// 			final int currentAI = match.getCurrentTurn();
+	// 			final long move = ais[currentAI].getMove(match);
+
+	// 			match.play(move);
+	// 		}
+
+	// 		if (match.getWinner() < 0) {
+	// 			ties++;
+	// 			continue;
+	// 		}
+
+	// 		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);
+	// }
 }

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

@@ -11,18 +11,20 @@ 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;
 import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.framework.networking.connection.clients.TournamentNetworkingClient;
 import org.toop.framework.networking.connection.events.NetworkEvents;
 import org.toop.framework.networking.connection.types.NetworkingConnector;
-import org.toop.framework.game.players.ArtificialPlayer;
-import org.toop.framework.game.players.OnlinePlayer;
-import org.toop.framework.game.players.RandomAI;
 import org.toop.framework.networking.server.gateway.NettyGatewayServer;
+import org.toop.framework.game.players.LocalPlayer;
+import org.toop.game.players.ai.MCTSAI3;
 import org.toop.local.AppContext;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executors;
@@ -118,7 +120,8 @@ public final class Server {
 				return;
 			}
 
-			primary = new ServerView(user, this::sendChallenge, clientId);
+			primary = new ServerView(user, this::sendChallenge, user, clientId);
+
 			WidgetContainer.getCurrentView().transitionNextCustom(primary, "disconnect", this::disconnect);
 
 			a.unsubscribe("connecting");
@@ -160,7 +163,8 @@ public final class Server {
                 .listen(NetworkEvents.GameResultResponse.class, this::handleGameResult, false, "game-result")
                 .listen(NetworkEvents.GameMoveResponse.class, this::handleReceivedMove, false, "game-move")
                 .listen(NetworkEvents.YourTurnResponse.class, this::handleYourTurn, false, "your-turn")
-				.listen(NetworkEvents.ClosedConnection.class, this::closedConnection, false, "closed-connection");
+				.listen(NetworkEvents.ClosedConnection.class, this::closedConnection, false, "closed-connection")
+                .listen(NetworkEvents.TournamentResultResponse.class, this::handleTournamentResult, false, "tournament-result");
 
 		connectFlow = a;
 	}
@@ -197,39 +201,22 @@ public final class Server {
                 return;
             }
 
-            final int myTurn = response.playerToMove().equalsIgnoreCase(response.opponent()) ? 1 : 0;
+            final String startingPlayer = response.playerToMove();
+            final int userStartingTurn = startingPlayer.equalsIgnoreCase(user) ? 0 : 1;
+            final int opponentStartingTurn = 1 - userStartingTurn;
 
             final GameInformation information = new GameInformation(type);
-            //information.players[0] = playerInformation;
-            information.players[0].name = user;
-            information.players[0].isHuman = false;
-            information.players[0].computerDifficulty = 5;
-            information.players[0].computerThinkTime = 1;
-            information.players[1].name = response.opponent();
-
-            /*switch (type){
-                case TICTACTOE ->{
-                    players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(9), user);
-                }
-                case REVERSI ->{
-                    players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
-                }
-            }*/
+            information.players[userStartingTurn].name = user;
+            information.players[opponentStartingTurn].name = response.opponent();
 
+            Player[] players = new Player[2];
 
+            players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(1000), user);
+            players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
 
             switch (type) {
-                case TICTACTOE ->{
-                        Player[] players = new Player[2];
-                        players[(myTurn + 1) % 2] = new OnlinePlayer(response.opponent());
-                        players[myTurn] = new ArtificialPlayer(new RandomAI(), user);
-                        gameController = new TicTacToeBitController(players);
-                }
-                case REVERSI -> {
-                    Player[] players = new Player[2];
-                    players[(myTurn + 1) % 2] = new OnlinePlayer(response.opponent());
-                    players[myTurn] = new ArtificialPlayer(new RandomAI(), user);
-                    gameController = new ReversiBitController(players);}
+                case TICTACTOE -> gameController = new TicTacToeBitController(players);
+                case REVERSI -> gameController = new ReversiBitController(players);
                 default -> new ErrorPopup("Unsupported game type.");
 
             }
@@ -257,6 +244,13 @@ public final class Server {
         gameController.gameFinished(response);
     }
 
+    private void handleTournamentResult(NetworkEvents.TournamentResultResponse response) {
+        IO.println(response.gameType());
+        IO.println(Arrays.toString(response.names()));
+		IO.println(Arrays.toString(response.scoreTypes()));
+        IO.println(Arrays.toString(response.scores().toArray()));
+    }
+
     private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
         if (gameController == null) {
             return;
@@ -356,7 +350,8 @@ public final class Server {
 
 	private void gamesListFromServerHandler(NetworkEvents.GamelistResponse event) {
 		gameList.clear();
-		var gl = List.of(event.gamelist());
+		var gl = new java.util.ArrayList<>(List.of(event.gamelist()));
+        gl.sort(String::compareTo);
 		gameList.addAll(gl);
 		primary.updateGameList(gl);
 	}

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

@@ -78,6 +78,7 @@ public abstract class BitGameCanvas implements GameCanvas {
 		}
 
 		canvas.setOnMouseClicked(event -> {
+
 			if (event.getButton() != MouseButton.PRIMARY) {
 				return;
 			}
@@ -93,9 +94,6 @@ public abstract class BitGameCanvas implements GameCanvas {
 			}
 		});
 
-
-
-
 		render();
 	}
 

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

@@ -1,7 +1,9 @@
 package org.toop.app.canvas;
 
 import javafx.scene.canvas.Canvas;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-public interface GameCanvas extends GameDrawer{
+public interface GameCanvas {
     Canvas getCanvas();
+    void redraw(TurnBasedGame gameCopy);
 }

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

@@ -1,7 +0,0 @@
-package org.toop.app.canvas;
-
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-
-public interface GameDrawer {
-    void redraw(TurnBasedGame gameCopy);
-}

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,12 +5,13 @@ 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;
 import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.gameFramework.controller.GameController;
-import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
+import org.toop.framework.gameFramework.model.game.threadBehaviour.SupportsOnlinePlay;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
 import org.toop.framework.gameFramework.model.player.Player;
@@ -35,14 +36,16 @@ public class GenericGameController implements GameController {
 
     // TODO: Change gameType to automatically happen with either dependency injection or something else.
     public GenericGameController(GameCanvas canvas, TurnBasedGame game, ThreadBehaviour gameThreadBehaviour, String gameType) {
-        logger.info("Creating: " + this.getClass());
+        logger.info("Creating: {}", this.getClass());
 
         this.canvas = canvas;
         this.game = game;
         this.gameThreadBehaviour = gameThreadBehaviour;
 
         // Tell thread how to send moves
-        this.gameThreadBehaviour.setOnSendMove((id, m) -> GlobalEventBus.get().post(new NetworkEvents.SendMove(id, (short)translateMove(m))));
+        this.gameThreadBehaviour.setOnSendMove(
+                (id, m) -> GlobalEventBus.get().post(new NetworkEvents.SendMove(id, (short)translateMove(m)))
+        );
 
         // Tell thread how to update UI
         this.gameThreadBehaviour.setOnUpdateUI(() -> Platform.runLater(this::updateUI));
@@ -53,23 +56,37 @@ public class GenericGameController implements GameController {
         WidgetContainer.getCurrentView().transitionNext(gameView, true);
 
         // Listen to updates
+        logger.info("Game controller started listening");
         eventFlow
                 .listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
                 .listen(GUIEvents.PlayerAttemptedMove.class, event -> {
-                    if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}
-                    }, false);
+                    logger.info("User attempting move {}", event.move());
+                    logger.info("Current player's turn {}", getCurrentPlayer().getName());
+                    logger.info("First player {}", game.getPlayer(0).getName());
+                    logger.info("Username {}", getCurrentPlayer().getName());
+                    logger.info("User is class {}, {}", getCurrentPlayer().getClass(), getCurrentPlayer() instanceof LocalPlayer);
+                    if (getCurrentPlayer() instanceof LocalPlayer lp) {
+                        try {
+                            lp.setLastMove(event.move());
+                        } catch (Exception e) {
+                            IO.println(e);
+                        }
+                    }
+                }, false);
     }
 
     public void start(){
         logger.info("Starting GameManager");
         updateUI();
         gameThreadBehaviour.start();
+        logger.info("GameManager started");
     }
 
     public void stop(){
         logger.info("Stopping GameManager");
         removeListeners();
         gameThreadBehaviour.stop();
+        logger.info("GameManager stopped");
     }
 
     public Player getCurrentPlayer(){
@@ -100,7 +117,7 @@ public class GenericGameController implements GameController {
     }
 
     public Player getPlayer(int player){
-        if (player < 0 || player >= 2){ // TODO: Make game turn player count
+        if (player < 0 || player > game.getPlayerCount()-1){ // TODO: Make game turn player count
             logger.error("Invalid player index");
             throw new IllegalArgumentException("player out of range");
         }
@@ -137,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/gameControllers/ReversiBitController.java

@@ -8,16 +8,16 @@ import org.toop.framework.game.gameThreads.OnlineThreadBehaviour;
 import org.toop.framework.game.games.reversi.BitboardReversi;
 import org.toop.framework.game.players.OnlinePlayer;
 
+import java.util.Arrays;
+
 public class ReversiBitController extends GenericGameController {
     public ReversiBitController(Player[] players) {
         BitboardReversi game = new BitboardReversi();
         game.init(players);
-        ThreadBehaviour thread = new LocalThreadBehaviour(game);
-        for (Player player : players) {
-            if (player instanceof OnlinePlayer){
-                thread = new OnlineThreadBehaviour(game);
-            }
-        }
+
+        ThreadBehaviour thread = Arrays.stream(players).anyMatch(e -> e instanceof OnlinePlayer) ?
+                new OnlineThreadBehaviour(game) : new LocalThreadBehaviour(game);
+
         super(new ReversiBitCanvas(), game, thread, "Reversi");
     }
 }

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

@@ -8,16 +8,16 @@ import org.toop.framework.game.gameThreads.OnlineThreadBehaviour;
 import org.toop.framework.game.games.tictactoe.BitboardTicTacToe;
 import org.toop.framework.game.players.OnlinePlayer;
 
+import java.util.Arrays;
+
 public class TicTacToeBitController extends GenericGameController {
     public TicTacToeBitController(Player[] players) {
         BitboardTicTacToe game = new BitboardTicTacToe();
         game.init(players);
-        ThreadBehaviour thread = new LocalThreadBehaviour(game);
-        for (Player player : players) {
-            if (player instanceof OnlinePlayer){
-                thread = new OnlineThreadBehaviour(game);
-            }
-        }
-        super(new TicTacToeBitCanvas(), game, thread , "TicTacToe");
+
+        ThreadBehaviour thread = Arrays.stream(players).anyMatch(e -> e instanceof OnlinePlayer) ?
+                new OnlineThreadBehaviour(game) : new LocalThreadBehaviour(game);
+
+        super(new TicTacToeBitCanvas(), game, thread, "TicTacToe");
     }
 }

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

@@ -6,17 +6,17 @@ import org.toop.app.gameControllers.ReversiBitController;
 import org.toop.app.gameControllers.TicTacToeBitController;
 import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.framework.game.games.reversi.BitboardReversi;
-import org.toop.framework.game.games.tictactoe.BitboardTicTacToe;
 import org.toop.framework.game.players.ArtificialPlayer;
-import org.toop.framework.game.players.LocalPlayer;
 import org.toop.app.widget.Primitive;
 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.MiniMaxAI;
-import org.toop.framework.game.players.RandomAI;
+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.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 RandomAI(), "Random AI");
+                        players[0] = new ArtificialPlayer(new MCTSAI(100), "MCTS AI");
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer(information.players[1].name);
@@ -82,12 +82,13 @@ public class LocalMultiplayerView extends ViewWidget {
                     if (information.players[0].isHuman) {
                         players[0] = new LocalPlayer(information.players[0].name);
                     } else {
-                        players[0] = new ArtificialPlayer(new RandomAI(), "Random AI");
+						// players[0] = new ArtificialPlayer(new RandomAI<BitboardReversi>(), "Random AI");
+						players[0] = new ArtificialPlayer(new MCTSAI3(50), "MCTS V3 AI");
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer(information.players[1].name);
                     } else {
-                        players[1] = new ArtificialPlayer(new MiniMaxAI(6), "MiniMax");
+						players[1] = new ArtificialPlayer(new MCTSAI(50), "MCTS V1 AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(

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

@@ -6,6 +6,8 @@ import javafx.scene.control.ComboBox;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.ViewWidget;
 
+import java.io.Reader;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Locale;
 import java.util.function.Consumer;
@@ -15,6 +17,7 @@ import javafx.geometry.Pos;
 import javafx.scene.control.Button;
 import javafx.scene.control.ListView;
 import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.networking.connection.events.NetworkEvents;
 
 public final class ServerView extends ViewWidget {
@@ -22,46 +25,65 @@ public final class ServerView extends ViewWidget {
 	private final Consumer<String> onPlayerClicked;
 	private final long clientId;
 
-	private final ComboBox<String> gameList;
+	private final ComboBox<String> gameListSub;
+    private final ComboBox<String> gameListTour;
 	private final ListView<Button> listView;
 	private Button subscribeButton;
 
-	public ServerView(String user, Consumer<String> onPlayerClicked, long clientId) {
+	public ServerView(String user, Consumer<String> onPlayerClicked, String userName, long clientId) {
 		this.user = user;
 		this.onPlayerClicked = onPlayerClicked;
 		this.clientId = clientId;
 
-		this.gameList = new ComboBox<>();
+		this.gameListSub = new ComboBox<>();
+        this.gameListTour = new ComboBox<>();
 		this.listView = new ListView<>();
 
-		setupLayout();
+		setupLayout(userName);
 	}
 
-	private void setupLayout() {
+	private void setupLayout(String userName) {
 		var playerHeader = Primitive.header(user, false);
 
-		subscribeButton = Primitive.button(
-				"subscribe",
-				() -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameList.getValue())).postEvent(),
-				false,
-				true
-		); // TODO localize
+        if (userName.equals("host")) { // TODO is fragile
+            var tournamentButton = Primitive.hbox(
+                    gameListTour,
+                    Primitive.button(
+                            "tournament",
+                            () -> GlobalEventBus.get().post(new NetworkEvents.SendCommand(clientId, "tournament", "start", gameListTour.getValue())),
+                            false,
+                            false
+                    )
+            );
 
-		var subscribe = Primitive.hbox(gameList, subscribeButton);
+            add(Pos.BOTTOM_CENTER, tournamentButton);
+        } else {
+            subscribeButton = Primitive.button(
+                    "subscribe",
+                    () -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameListSub.getValue())).postEvent(),
+                    false,
+                    true
+            ); // TODO localize
 
-		var playerListSection = Primitive.vbox(
-			playerHeader,
-			Primitive.separator(),
-			subscribe,
-			listView
-		);
+            var subscribe = Primitive.hbox(gameListSub, subscribeButton);
 
-		add(Pos.CENTER, playerListSection);
+            var playerListSection = Primitive.vbox(
+                    playerHeader,
+                    Primitive.separator(),
+                    subscribe,
+                    listView
+            );
 
-		var disconnectButton = Primitive.button(
-				"disconnect", () -> transitionPrevious(), false);
+            add(Pos.CENTER, playerListSection);
 
-		add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
+            var disconnectButton = Primitive.button(
+                    "disconnect",
+					this::transitionPrevious,
+					false
+			);
+
+            add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
+        }
 	}
 
 	public void update(List<String> players) {
@@ -77,9 +99,13 @@ public final class ServerView extends ViewWidget {
 
 	public void updateGameList(List<String> games) {
 		Platform.runLater(() -> {
-			gameList.getItems().clear();
-			gameList.setItems(FXCollections.observableArrayList(games));
-			gameList.getSelectionModel().select(0);
+			gameListSub.getItems().clear();
+			gameListSub.setItems(FXCollections.observableArrayList(games));
+			gameListSub.getSelectionModel().select(0);
+
+            gameListTour.getItems().clear();
+            gameListTour.setItems(FXCollections.observableArrayList(games));
+            gameListTour.getSelectionModel().select(0);
 		});
 	}
 

framework/src/main/java/org/toop/framework/eventbus/EventFlow.java

@@ -415,11 +415,9 @@ public class EventFlow {
     /**
      * Posts the event added through {@link #addPostEvent} asynchronously.
      *
-     * @deprecated use {@link #postEvent()} instead.
      */
-    @Deprecated
     public EventFlow asyncPostEvent() {
-        eventBus.post(this.event);
+        GlobalEventBus.get().post(this.event);
         return this;
     }
 

framework/src/main/java/org/toop/framework/eventbus/GlobalEventBus.java

@@ -1,15 +1,20 @@
 package org.toop.framework.eventbus;
 
 import org.apache.logging.log4j.LogManager;
+import org.toop.framework.eventbus.bus.AsyncEventBus;
+import org.toop.framework.eventbus.bus.DefaultEventBus;
 import org.toop.framework.eventbus.bus.DisruptorEventBus;
 import org.toop.framework.eventbus.bus.EventBus;
 import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.store.DefaultSubscriberStore;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
-public class GlobalEventBus implements EventBus {
-    private static final EventBus INSTANCE = new DisruptorEventBus(
-            LogManager.getLogger(DisruptorEventBus.class),
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+public class GlobalEventBus implements AsyncEventBus {
+    private static final AsyncEventBus INSTANCE = new DefaultEventBus(
+            LogManager.getLogger(DefaultEventBus.class),
             new DefaultSubscriberStore()
     );
 
@@ -34,6 +39,11 @@ public class GlobalEventBus implements EventBus {
         INSTANCE.post(event);
     }
 
+    @Override
+    public <T extends EventType> void asyncPost(T event) {
+        INSTANCE.asyncPost(event);
+    }
+
     @Override
     public void shutdown() {
         INSTANCE.shutdown();
@@ -43,4 +53,5 @@ public class GlobalEventBus implements EventBus {
     public void reset() {
         INSTANCE.reset();
     }
+
 }

framework/src/main/java/org/toop/framework/eventbus/bus/AsyncEventBus.java

@@ -0,0 +1,7 @@
+package org.toop.framework.eventbus.bus;
+
+import org.toop.framework.eventbus.events.EventType;
+
+public interface AsyncEventBus extends EventBus {
+    <T extends EventType> void asyncPost(T event);
+}

framework/src/main/java/org/toop/framework/eventbus/bus/DefaultEventBus.java

@@ -5,12 +5,16 @@ import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.store.SubscriberStore;
 import org.toop.framework.eventbus.subscriber.Subscriber;
 
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 import java.util.function.Consumer;
 
-public class DefaultEventBus implements EventBus {
+public class DefaultEventBus implements AsyncEventBus {
     private final Logger logger;
     private final SubscriberStore eventsHolder;
 
+    private final ExecutorService asyncExecutor = Executors.newCachedThreadPool();
+
     public DefaultEventBus(Logger logger, SubscriberStore eventsHolder) {
         this.logger = logger;
         this.eventsHolder = eventsHolder;
@@ -36,11 +40,16 @@ public class DefaultEventBus implements EventBus {
                 Class<T> eventClass = (Class<T>) subscriber.event();
                 Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
 
-                action.accept((EventType) eventClass.cast(event));
+                action.accept(eventClass.cast(event));
             }
         }
     }
 
+    @Override
+    public <T extends EventType> void asyncPost(T event) {
+        asyncExecutor.submit(() -> post(event));
+    }
+
     @Override
     public void shutdown() {
         eventsHolder.reset();
@@ -50,4 +59,5 @@ public class DefaultEventBus implements EventBus {
     public void reset() {
         eventsHolder.reset();
     }
+
 }

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

@@ -1,5 +1,7 @@
 package org.toop.framework.game;
 
+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.Player;
 
@@ -10,6 +12,8 @@ public abstract class BitboardGame implements TurnBasedGame {
 	private final int columnSize;
 	private final int rowSize;
 
+	protected PlayResult state;
+
     private Player[] players;
 
 	// long is 64 bits. Every game has a limit of 64 cells maximum.
@@ -20,26 +24,34 @@ public abstract class BitboardGame implements TurnBasedGame {
 	public BitboardGame(int columnSize, int rowSize, int playerCount) {
 		this.columnSize = columnSize;
 		this.rowSize = rowSize;
-		this.playerCount = playerCount;
-        this.playerBitboard = new long[playerCount];
-	}
+        this.playerCount = playerCount;
+		this.state = new PlayResult(GameState.NORMAL, -1);
 
-	@Override
-	public void init(Player[] players) {
-		this.players = players;
+		this.playerBitboard = new long[playerCount];
 
 		Arrays.fill(playerBitboard, 0L);
 	}
 
+    @Override
+    public void init(Player[] players) {
+        this.players = players;
+
+        Arrays.fill(playerBitboard, 0L);
+    }
+
 	public BitboardGame(BitboardGame other) {
 		this.columnSize = other.columnSize;
 		this.rowSize = other.rowSize;
         this.playerCount = other.playerCount;
+		this.state = other.state;
+
 		this.playerBitboard = other.playerBitboard.clone();
 		this.currentTurn = other.currentTurn;
-        this.players = Arrays.stream(other.players)
-                .map(Player::deepCopy)
-                .toArray(Player[]::new);
+        this.players = other.players;
+        // TODO: Players are not deep copied, which is bad. I don't know why but deepcopying breaks it. Fix it
+        //this.players = Arrays.stream(other.players)
+        //        .map(Player::deepCopy)
+        //        .toArray(Player[]::new);
 	}
 
 	public int getColumnSize() {
@@ -80,9 +92,17 @@ public abstract class BitboardGame implements TurnBasedGame {
         return players[getCurrentPlayerIndex()];
     }
 
+	@Override
+	public PlayResult getState() {
+		return state;
+	}
 
+	@Override
+	public boolean isTerminal() {
+		return state.state() == GameState.WIN || state.state() == GameState.DRAW;
+	}
 
-    @Override
+	@Override
     public long[] getBoard() {return this.playerBitboard;}
 
 	public void nextTurn() {

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

@@ -4,10 +4,13 @@ import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.AbstractThreadBehaviour;
 import org.toop.framework.gameFramework.view.GUIEvents;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
+import org.toop.framework.gameFramework.model.game.threadBehaviour.SupportsOnlinePlay;
 import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.framework.game.players.OnlinePlayer;
 
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
 /**
  * Handles online multiplayer game logic.
  * <p>
@@ -15,6 +18,9 @@ import org.toop.framework.game.players.OnlinePlayer;
  * for the local player while receiving moves from other players.
  */
 public class OnlineThreadBehaviour extends AbstractThreadBehaviour implements SupportsOnlinePlay {
+
+    private ExecutorService moveExecutor = Executors.newSingleThreadExecutor();
+
     /**
      * Creates behaviour and sets the first local player
      * (non-online player) from the given array.
@@ -51,8 +57,30 @@ public class OnlineThreadBehaviour extends AbstractThreadBehaviour implements Su
      */
     @Override
     public void onYourTurn(long clientId) {
-        if (!isRunning.get()) return;
-        long move = game.getPlayer(game.getCurrentTurn()).getMove(game.deepCopy());
+        logger.info("Yourturn");
+        if (!isRunning.get()) {
+            logger.warn("Game is not running!");
+            return;
+        }
+
+        TurnBasedGame gameCopy = game.deepCopy();
+        if (gameCopy == null) {
+            logger.error("Could not deep copy game");
+            return;
+        }
+        logger.info("Successfully collected game copy");
+
+        Player player = gameCopy.getPlayer(game.getCurrentTurn());
+        if (player == null) {
+            logger.error("Could not find current turn's player");
+            return;
+        }
+        logger.info("Successfully collected current turn's player");
+
+        long move = player.getMove(gameCopy);
+        logger.info("Move set: {}", move);
+        logger.info("Completed onYourTurn");
+
         sendMove(clientId, move);
     }
 

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

@@ -32,47 +32,227 @@ public class BitboardReversi extends BitboardGame {
     }
 
 	public long getLegalMoves() {
+		long legalMoves = 0L;
+
 		final long player = getPlayerBitboard(getCurrentPlayerIndex());
 		final long opponent = getPlayerBitboard(getNextPlayer());
 
-		long legalMoves = 0L;
+		final long empty = ~(player | opponent);
 
-		// north & south
-		legalMoves |= computeMoves(player, opponent, 8, -1L);
-		legalMoves |= computeMoves(player, opponent, -8, -1L);
+		long mask;
+		long direction;
 
-		// east & west
-		legalMoves |= computeMoves(player, opponent, 1, notAFile);
-		legalMoves |= computeMoves(player, opponent, -1, notHFile);
+		// north
+		mask = opponent;
+		direction = (player << 8) & mask;
 
-		// north-east & north-west & south-east & south-west
-		legalMoves |= computeMoves(player, opponent, 9, notAFile);
-		legalMoves |= computeMoves(player, opponent, 7, notHFile);
-		legalMoves |= computeMoves(player, opponent, -7, notAFile);
-		legalMoves |= computeMoves(player, opponent, -9, notHFile);
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		legalMoves |= (direction << 8) & empty;
+
+		// south
+		mask = opponent;
+		direction = (player >>> 8) & mask;
+
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		legalMoves |= (direction >>> 8) & empty;
+
+		// east
+		mask = opponent & notAFile;
+		direction = (player << 1) & mask;
+
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		legalMoves |= (direction << 1) & empty & notAFile;
+
+		// west
+		mask = opponent & notHFile;
+		direction = (player >>> 1) & mask;
+
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		legalMoves |= (direction >>> 1) & empty & notHFile;
+
+		// north-east
+		mask = opponent & notAFile;
+		direction = (player << 9) & mask;
+
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		legalMoves |= (direction << 9) & empty & notAFile;
+
+		// north-west
+		mask = opponent & notHFile;
+		direction = (player << 7) & mask;
+
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		legalMoves |= (direction << 7) & empty & notHFile;
+
+		// south-east
+		mask = opponent & notAFile;
+		direction = (player >>> 7) & mask;
+
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		legalMoves |= (direction >>> 7) & empty & notAFile;
+
+		// south-west
+		mask = opponent & notHFile;
+		direction = (player >>> 9) & mask;
+
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		legalMoves |= (direction >>> 9) & empty & notHFile;
 
 		return legalMoves;
 	}
 
 	public long getFlips(long move) {
+		long flips = 0L;
+
 		final long player = getPlayerBitboard(getCurrentPlayerIndex());
 		final long opponent = getPlayerBitboard(getNextPlayer());
 
-		long flips = 0L;
+		long mask;
+		long direction;
 
-		// north & south
-		flips |= computeFlips(move, player, opponent, 8, -1L);
-		flips |= computeFlips(move, player, opponent, -8, -1L);
+		// north
+		mask = opponent;
+		direction = (move << 8) & mask;
 
-		// east & west
-		flips |= computeFlips(move, player, opponent, 1, notAFile);
-		flips |= computeFlips(move, player, opponent, -1, notHFile);
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
+		direction |= (direction << 8) & mask;
 
-		// north-east & north-west & south-east & south-west
-		flips |= computeFlips(move, player, opponent, 9, notAFile);
-		flips |= computeFlips(move, player, opponent, 7, notHFile);
-		flips |= computeFlips(move, player, opponent, -7, notAFile);
-		flips |= computeFlips(move, player, opponent, -9, notHFile);
+		if (((direction << 8) & player) != 0) {
+			flips |= direction;
+		}
+
+		// south
+		mask = opponent;
+		direction = (move >>> 8) & mask;
+
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+		direction |= (direction >>> 8) & mask;
+
+		if (((direction >>> 8) & player) != 0) {
+			flips |= direction;
+		}
+
+		// east
+		mask = opponent & notAFile;
+		direction = (move << 1) & mask;
+
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+		direction |= (direction << 1) & mask;
+
+		if (((direction << 1) & player & notAFile) != 0) {
+			flips |= direction;
+		}
+
+		// west
+		mask = opponent & notHFile;
+		direction = (move >>> 1) & mask;
+
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+		direction |= (direction >>> 1) & mask;
+
+		if (((direction >>> 1) & player & notHFile) != 0) {
+			flips |= direction;
+		}
+
+		// north-east
+		mask = opponent & notAFile;
+		direction = (move << 9) & mask;
+
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+		direction |= (direction << 9) & mask;
+
+		if (((direction << 9) & player & notAFile) != 0) {
+			flips |= direction;
+		}
+
+		// north-west
+		mask = opponent & notHFile;
+		direction = (move << 7) & mask;
+
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+		direction |= (direction << 7) & mask;
+
+		if (((direction << 7) & player & notHFile) != 0) {
+			flips |= direction;
+		}
+
+		// south-east
+		mask = opponent & notAFile;
+		direction = (move >>> 7) & mask;
+
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+		direction |= (direction >>> 7) & mask;
+
+		if (((direction >>> 7) & player & notAFile) != 0) {
+			flips |= direction;
+		}
+
+		// south-west
+		mask = opponent & notHFile;
+		direction = (move >>> 9) & mask;
+
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+		direction |= (direction >>> 9) & mask;
+
+		if (((direction >>> 9) & player & notHFile) != 0) {
+			flips |= direction;
+		}
 
 		return flips;
 	}
@@ -105,16 +285,20 @@ public class BitboardReversi extends BitboardGame {
 				int winner = getWinner();
 
 				if (winner == -1) {
-					return new PlayResult(GameState.DRAW, -1);
+					state = new PlayResult(GameState.DRAW, -1);
+					return state;
 				}
 
-				return new PlayResult(GameState.WIN, winner);
+				state = new PlayResult(GameState.WIN, winner);
+				return state;
 			}
 
-			return new PlayResult(GameState.TURN_SKIPPED, getCurrentPlayerIndex());
+			state = new PlayResult(GameState.TURN_SKIPPED, getCurrentPlayerIndex());
+			return state;
 		}
 
-		return new PlayResult(GameState.NORMAL, getCurrentPlayerIndex());
+		state = new PlayResult(GameState.NORMAL, getCurrentPlayerIndex());
+		return state;
 	}
 
 	public Score getScore() {
@@ -141,35 +325,4 @@ public class BitboardReversi extends BitboardGame {
             return 1;
         }
     }
-
-	private long computeMoves(long player, long opponent, int shift, long mask) {
-		long moves = shift(player, shift, mask) & opponent;
-		long captured = moves;
-
-		while (moves != 0) {
-			moves = shift(moves, shift, mask) & opponent;
-			captured |= moves;
-		}
-
-		long landing = shift(captured, shift, mask);
-		return landing & ~(player | opponent);
-	}
-
-	private long computeFlips(long move, long player, long opponent, int shift, long mask) {
-		long flips = 0L;
-		long pos = move;
-
-		while (true) {
-			pos = shift(pos, shift, mask);
-			if (pos == 0) return 0L;
-
-			if ((pos & opponent) != 0) flips |= pos;
-			else if ((pos & player) != 0) return flips;
-			else return 0L;
-		}
-	}
-
-	private long shift(long bit, int shift, long mask) {
-		return shift > 0 ? (bit << shift) & mask : (bit >>> -shift) & mask;
-	}
 }

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

@@ -45,7 +45,8 @@ public class BitboardTicTacToe extends BitboardGame {
 	public PlayResult play(long move) {
         // Player loses if move is invalid
         if ((move & getLegalMoves()) == 0 || Long.bitCount(move) != 1){
-            return new PlayResult(GameState.WIN, getNextPlayer());
+            state = new PlayResult(GameState.WIN, getNextPlayer());
+			return state;
         }
 
         // Move is legal, make move
@@ -56,7 +57,8 @@ public class BitboardTicTacToe extends BitboardGame {
 
         // Check if current player won
         if (checkWin(playerBitboard)) {
-            return new PlayResult(GameState.WIN, getCurrentPlayerIndex());
+			state = new PlayResult(GameState.WIN, getCurrentPlayerIndex());
+            return state;
         }
 
         // Proceed to next turn
@@ -65,11 +67,13 @@ public class BitboardTicTacToe extends BitboardGame {
 
         // Check for early draw
 		if (getLegalMoves() == 0L || checkEarlyDraw()) {
-			return new PlayResult(GameState.DRAW, -1);
+			state = new PlayResult(GameState.DRAW, -1);
+			return state;
 		}
 
         // Nothing weird happened, continue on as normal
-		return new PlayResult(GameState.NORMAL, -1);
+		state = new PlayResult(GameState.NORMAL, -1);
+		return state;
 	}
 
 	private boolean checkWin(long board) {

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

@@ -44,10 +44,15 @@ public class ArtificialPlayer extends AbstractPlayer {
      * @return the integer representing the chosen move
      * @throws ClassCastException if {@code gameCopy} is not of type {@code T}
      */
-    public long getMove(TurnBasedGame gameCopy) {
+    protected long determineMove(TurnBasedGame gameCopy) {
         return ai.getMove(gameCopy);
     }
 
+    /**
+     * Creates a deep copy of this AI player.
+     *
+     * @return a copy of this player
+     */
     @Override
     public ArtificialPlayer deepCopy() {
         return new ArtificialPlayer(this);

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

@@ -6,65 +6,88 @@ import org.toop.framework.gameFramework.model.player.AbstractPlayer;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
+/**
+ * Represents a local player who provides moves manually.
+ *
+ * @param <T> the type of turn-based game
+ */
 public class LocalPlayer extends AbstractPlayer {
-    // Future can be used with event system, IF unsubscribeAfterSuccess works...
-    // private CompletableFuture<Integer> LastMove = new CompletableFuture<>();
 
-    private CompletableFuture<Long> LastMove;
+    private CompletableFuture<Long> LastMove = new CompletableFuture<>();
 
+    /**
+     * Creates a new local player with the given name.
+     *
+     * @param name the player's name
+     */
     public LocalPlayer(String name) {
         super(name);
     }
 
+    /**
+     * Creates a copy of another local player.
+     *
+     * @param other the player to copy
+     */
     public LocalPlayer(LocalPlayer other) {
         super(other);
+        this.LastMove = other.LastMove;
     }
 
+    /**
+     * Waits for and returns the player's next legal move.
+     *
+     * @param gameCopy a copy of the current game
+     * @return the chosen move
+     */
     @Override
-    public long getMove(TurnBasedGame gameCopy) {
-        return getValidMove(gameCopy);
+    protected long determineMove(TurnBasedGame gameCopy) {
+        long legalMoves = gameCopy.getLegalMoves();
+        long move;
+
+        try {
+            do {
+                move = getLastMove();
+                IO.println("GETTING MOVE");
+            } while ((legalMoves & move) == 0);
+            return move;
+        } catch (Exception e) {
+            IO.println(e);
+        }
+        return -1;
     }
 
-    public void setMove(long move) {
+    /**
+     * Sets the player's last move.
+     *
+     * @param move the move to set
+     */
+    public void setLastMove(long move) {
         LastMove.complete(move);
     }
 
-    // TODO: helper function, would like to replace to get rid of this method
-    public static boolean contains(int[] array, int value){
-        for (int i : array) if (i == value) return true;
-        return false;
-    }
-
-    private long getMove2(TurnBasedGame gameCopy) {
-        LastMove = new CompletableFuture<>();
-        long move = 0;
+    /**
+     * Waits for the next move from the player.
+     *
+     * @return the chosen move or 0 if interrupted
+     */
+    private long getLastMove() {
+        LastMove = new CompletableFuture<>(); // Reset the future
         try {
-            move = LastMove.get();
-            System.out.println(Long.toBinaryString(move));
-        } catch (InterruptedException | ExecutionException e) {
-            // TODO: Add proper logging.
-            e.printStackTrace();
+            return LastMove.get();
+        } catch (ExecutionException | InterruptedException e) {
+            return 0;
         }
-        return move;
-    }
-
-    protected long getValidMove(TurnBasedGame gameCopy){
-        // Get this player's valid moves
-        long validMoves = gameCopy.getLegalMoves();
-        // Make sure provided move is valid
-        // TODO: Limit amount of retries?
-        // TODO: Stop copying game so many times
-        long move = getMove2(gameCopy.deepCopy());
-        while ((validMoves & move) == 0) {
-            System.out.println("Not a valid move, try again");
-            move = getMove2(gameCopy.deepCopy());
-        }
-        return move;
     }
 
+    /**
+     * Creates a deep copy of this local player.
+     *
+     * @return a copy of this player
+     */
     @Override
     public LocalPlayer deepCopy() {
-        return new LocalPlayer(this.getName());
+        return new LocalPlayer(this);
     }
 
     /*public void register() {

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

@@ -5,30 +5,45 @@ import org.toop.framework.gameFramework.model.player.AbstractPlayer;
 import org.toop.framework.gameFramework.model.player.Player;
 
 /**
- * Represents a player controlled remotely or over a network.
- * <p>
- * This class extends {@link AbstractPlayer} and can be used to implement game logic
- * where moves are provided by an external source (e.g., another user or a server).
- * Currently, this class is a placeholder and does not implement move logic.
- * </p>
+ * Represents a player that participates online.
+ *
+ * @param <T> the type of turn-based game
  */
 public class OnlinePlayer extends AbstractPlayer {
 
     /**
-     * Constructs a new OnlinePlayer.
-     * <p>
-     * Currently, no additional initialization is performed. Subclasses or
-     * future implementations should provide mechanisms to receive moves from
-     * an external source.
+     * Creates a new online player with the given name.
+     *
+     * @param name the name of the player
      */
     public OnlinePlayer(String name) {
         super(name);
     }
 
+    /**
+     * Creates a copy of another online player.
+     *
+     * @param other the player to copy
+     */
     public OnlinePlayer(OnlinePlayer other) {
         super(other);
     }
 
+    /**
+     * {@inheritDoc}
+     * <p>
+     * This method is not supported for online players.
+     *
+     * @throws UnsupportedOperationException always
+     */
+    @Override
+    protected long determineMove(TurnBasedGame gameCopy) {
+        throw new UnsupportedOperationException("An online player does not support determining move");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
     @Override
     public Player deepCopy() {
         return new OnlinePlayer(this);

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

@@ -27,15 +27,10 @@ public class ServerPlayer extends AbstractPlayer {
     }
 
     @Override
-    public long getMove(TurnBasedGame game) {
+    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/controller/GameController.java

@@ -1,9 +1,8 @@
 package org.toop.framework.gameFramework.controller;
 
-import org.toop.framework.gameFramework.model.game.threadBehaviour.Controllable;
 import org.toop.framework.networking.connection.events.NetworkEvents;
 
-public interface GameController extends Controllable, UpdatesGameUI {
+public interface GameController {
     /** Called when it is this player's turn to make a move. */
     void onYourTurn(NetworkEvents.YourTurnResponse event);
 
@@ -13,5 +12,12 @@ public interface GameController extends Controllable, UpdatesGameUI {
     /** Called when the game has finished, with the final result. */
     void gameFinished(NetworkEvents.GameResultResponse event);
 
+    void start();
+
+    void stop();
+
+    /** Called to refresh or update the game UI. */
+    void updateUI();
+
     void sendMove(long clientId, long move);
 }

framework/src/main/java/org/toop/framework/gameFramework/controller/UpdatesGameUI.java

@@ -1,10 +0,0 @@
-package org.toop.framework.gameFramework.controller;
-
-/**
- * Interface for classes that can trigger a UI update.
- */
-public interface UpdatesGameUI {
-
-    /** Called to refresh or update the game UI. */
-    void updateUI();
-}

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

@@ -1,5 +0,0 @@
-package org.toop.framework.gameFramework.model.game;
-
-public interface BoardProvider {
-    long[] getBoard();
-}

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

@@ -1,24 +0,0 @@
-package org.toop.framework.gameFramework.model.game;
-
-import org.toop.framework.gameFramework.GameState;
-
-/**
- * Interface for turn-based games that can be played and queried for legal moves.
- */
-public interface Playable {
-
-    /**
-     * Returns the moves that are currently valid in the game.
-     *
-     * @return an array of integers representing legal moves
-     */
-    long getLegalMoves();
-
-    /**
-     * Plays the given move and returns the resulting game state.
-     *
-     * @param move the move to apply
-     * @return the {@link GameState} and additional info after the move
-     */
-    PlayResult play(long move);
-}

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

@@ -1,7 +0,0 @@
-package org.toop.framework.gameFramework.model.game;
-
-import org.toop.framework.gameFramework.model.player.Player;
-
-public interface PlayerProvider {
-    Player getPlayer(int index);
-}

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

@@ -2,9 +2,15 @@ package org.toop.framework.gameFramework.model.game;
 
 import org.toop.framework.gameFramework.model.player.Player;
 
-public interface TurnBasedGame extends Playable, PlayerProvider, BoardProvider, DeepCopyable<TurnBasedGame> {
+public interface TurnBasedGame extends DeepCopyable<TurnBasedGame> {
     void init(Player[] players);
+    long[] getBoard();
     int getCurrentTurn();
     int getPlayerCount();
+    Player getPlayer(int index);
     int getWinner();
+    long getLegalMoves();
+    PlayResult play(long move);
+	PlayResult getState();
+	boolean isTerminal();
 }

framework/src/main/java/org/toop/framework/gameFramework/model/game/threadBehaviour/AbstractThreadBehaviour.java

@@ -3,7 +3,6 @@ package org.toop.framework.gameFramework.model.game.threadBehaviour;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.framework.gameFramework.LongPairConsumer;
-import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 import java.util.concurrent.atomic.AtomicBoolean;

framework/src/main/java/org/toop/framework/gameFramework/model/game/threadBehaviour/Controllable.java

@@ -1,7 +0,0 @@
-package org.toop.framework.gameFramework.model.game.threadBehaviour;
-
-public interface Controllable {
-    void start();
-
-    void stop();
-}

framework/src/main/java/org/toop/framework/gameFramework/model/game/threadBehaviour/SupportsOnlinePlay.java

@@ -1,4 +1,4 @@
-package org.toop.framework.gameFramework.model.game;
+package org.toop.framework.gameFramework.model.game.threadBehaviour;
 
 /**
  * Interface for games that support online multiplayer play.

framework/src/main/java/org/toop/framework/gameFramework/model/game/threadBehaviour/ThreadBehaviour.java

@@ -11,8 +11,11 @@ import java.util.function.Consumer;
  * <p>
  * Defines how a game's execution is started, stopped, and which player is active.
  */
-public interface ThreadBehaviour extends Controllable {
+public interface ThreadBehaviour {
     void setOnUpdateUI(Runnable onUpdateUI);
     void setOnSendMove(LongPairConsumer onSendMove);
+    void start();
+    void stop();
+
 }
 

framework/src/main/java/org/toop/framework/gameFramework/model/player/AI.java

@@ -3,5 +3,6 @@ package org.toop.framework.gameFramework.model.player;
 import org.toop.framework.gameFramework.model.game.DeepCopyable;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-public interface AI extends MoveProvider, DeepCopyable<AI> {
+public interface AI extends DeepCopyable<AI> {
+    long getMove(TurnBasedGame game);
 }

framework/src/main/java/org/toop/framework/gameFramework/model/player/AbstractPlayer.java

@@ -40,12 +40,29 @@ public abstract class AbstractPlayer implements Player {
      * @return an integer representing the chosen move
      * @throws UnsupportedOperationException if the method is not overridden
      */
-    public long getMove(TurnBasedGame gameCopy) {
-        logger.error("Method getMove not implemented.");
-        throw new UnsupportedOperationException("Not supported yet.");
+    public final long getMove(TurnBasedGame game) {
+        return determineMove(game.deepCopy());
     }
 
-    public final String getName(){
+
+    /**
+     * Determines the player's move using a safe copy of the game.
+     * <p>
+     * This method is called by {@link #getMove(T)} and should contain
+     * the player's strategy for choosing a move.
+     *
+     * @param gameCopy a deep copy of the game
+     * @return the chosen move
+     */
+    protected abstract long determineMove(TurnBasedGame gameCopy);
+
+
+    /**
+     * Returns the player's name.
+     *
+     * @return the name
+     */
+    public String getName() {
         return this.name;
     }
 }

framework/src/main/java/org/toop/framework/gameFramework/model/player/MoveProvider.java

@@ -1,7 +0,0 @@
-package org.toop.framework.gameFramework.model.player;
-
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-
-public interface MoveProvider {
-    long getMove(TurnBasedGame game);
-}

framework/src/main/java/org/toop/framework/gameFramework/model/player/NameProvider.java

@@ -1,5 +0,0 @@
-package org.toop.framework.gameFramework.model.player;
-
-public interface NameProvider {
-    String getName();
-}

framework/src/main/java/org/toop/framework/gameFramework/model/player/Player.java

@@ -1,5 +1,9 @@
 package org.toop.framework.gameFramework.model.player;
 
 import org.toop.framework.gameFramework.model.game.DeepCopyable;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-public interface Player extends NameProvider, MoveProvider, DeepCopyable<Player> {}
+public interface Player extends DeepCopyable<Player> {
+    String getName();
+    long getMove(TurnBasedGame game);
+}

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

@@ -65,6 +65,9 @@ public class NetworkEvents extends EventsBase {
     public record GameResultResponse(long clientId, String condition)
             implements GenericEvent {}
 
+    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. */
     public record GameMoveResponse(long clientId, String player, String move, String details)
             implements GenericEvent {}
@@ -219,4 +222,5 @@ public class NetworkEvents extends EventsBase {
     /** Response to a {@link ChangeAddress} event, carrying the success result. */
     public record ChangeAddressResponse(boolean successful, long identifier)
             implements ResponseToUniqueEvent {}
+
 }

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

@@ -3,6 +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;
@@ -94,6 +97,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                     case "HELP":
                         helpHandler(recSrvRemoved);
                         return;
+                    case "RESULTS":
+                        resultsHandler(recSrvRemoved);
+                        return;
                     default:
                         // return
                 }
@@ -103,6 +109,66 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
         }
     }
 
+    private static String extract(String input, String key) {
+        Pattern p = Pattern.compile(
+                key + "\\s*:\\s*(\\[[^]]*]|\"[^\"]*\")",
+                Pattern.CASE_INSENSITIVE
+        );
+        Matcher m = p.matcher(input);
+        return m.find() ? m.group(1) : null;
+    }
+
+    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;
+
+        String[] users;
+        if (usersRaw.length() > 2) {
+            users = Arrays.stream(usersRaw.substring(1, usersRaw.length() - 1).split(","))
+                .map(s -> s.trim().replace("\"", ""))
+                .toArray(String[]::new);
+        } else {
+            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) {
+            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, scoreTypes, scores));
+        } else {
+            eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scoreTypes, new ArrayList<>()));
+        }
+
+    }
+
     private void gameMoveHandler(String rec) {
         String[] msg =
                 Pattern.compile(

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

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+import java.util.concurrent.CompletableFuture;
+
+public record GameResultFuture(OnlineGame<TurnBasedGame> game, CompletableFuture<Integer> result) {}

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

@@ -1,9 +1,13 @@
 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> {
-    void 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,44 +5,65 @@ import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.networking.server.client.NettyClient;
 
+import java.time.Duration;
+import java.util.Arrays;
+import java.util.concurrent.CompletableFuture;
+
 public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
 
     private long id;
     private NettyClient[] clients;
+    private NettyClient[] admins;
     private TurnBasedGame game;
     private ServerThreadBehaviour gameThread;
 
-    public OnlineTurnBasedGame(TurnBasedGame game, NettyClient... clients) {
+    private final CompletableFuture<Integer> resultFuture;
+
+    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;
+        this.admins = admins;
     }
 
     private void notifyMoveMade(String speler, int move){
+        for (NettyClient admin : admins) {
+            admin.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}", speler, move));
+        }
         for (NettyClient client : clients) {
-            client.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}\n", speler, move));
+            client.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}", speler, move));
         }
     }
 
-    private void notifyGameEnd(GameState state, int winner){
-        if (state == GameState.DRAW){
+    private void notifyGameEnd(GameState state, int winner) {
+        if (state == GameState.DRAW) {
+            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>\"}\n"));
+                client.send("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}");
             }
-        }
-        else{
-            clients[winner].send(String.format("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}\n"));
-            clients[(winner + 1)%2].send(String.format("SVR GAME LOSS {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}\n"));
+        } else {
+            Arrays.stream(admins).forEach(a -> a.send("SVR GAME END"));
+            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 fromt clients
-        for(NettyClient client : clients) {
+        // Remove game from clients
+        for (NettyClient client : clients) {
+            admins = null;
             client.clearGame();
         }
+
+        if (resultFuture != null) {
+            if (state.equals(GameState.DRAW)) resultFuture.complete(-1); // Return -1 if draw
+            else resultFuture.complete(winner); // Return number for winner's index
+        }
     }
 
     @Override
@@ -61,7 +82,7 @@ public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
     }
 
     @Override
-    public void start(){
+    public void start() {
         this.gameThread.start();
     }
 }

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

@@ -1,5 +1,6 @@
 package org.toop.framework.networking.server;
 
+import com.google.gson.Gson;
 import org.toop.framework.game.players.ServerPlayer;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.networking.server.challenges.gamechallenge.GameChallenge;
@@ -9,6 +10,9 @@ import org.toop.framework.networking.server.stores.ClientStore;
 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.DoubleRoundRobinMatchMaker;
+import org.toop.framework.networking.server.tournaments.scoresystems.*;
 import org.toop.framework.utils.ImmutablePair;
 
 import java.util.*;
@@ -27,13 +31,14 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
     final private Duration challengeDuration;
     final private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
 
+    private final List<NettyClient> admins = new ArrayList<>();
+
     public Server(
             Duration challengeDuration,
             TurnBasedGameTypeStore turnBasedGameTypeStore,
             ClientStore<Long, NettyClient> clientStore,
             TurnBasedGameStore gameStore,
             SubscriptionStore subStore
-
     ) {
         this.gameTypesStore = turnBasedGameTypeStore;
         this.challengeDuration = challengeDuration;
@@ -46,11 +51,13 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
 
     @Override
     public void addClient(NettyClient client) {
+        if (admins.isEmpty()) admins.addLast(client);
         clientStore.add(client);
     }
 
     @Override
     public void removeClient(NettyClient client) {
+        admins.remove(client);
         clientStore.remove(client.id());
     }
 
@@ -103,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;
             }
         }
@@ -125,18 +132,29 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
     }
 
     @Override
-    public void startGame(String gameType, NettyClient... clients) {
-        if (!gameTypesStore.all().containsKey(gameType)) return;
+    public GameResultFuture startGame(String gameType, Duration turnTime, NettyClient... clients) {
+        if (!gameTypesStore.all().containsKey(gameType)) return null;
 
         try {
+
             ServerPlayer[] players = new ServerPlayer[clients.length];
-            var game = new OnlineTurnBasedGame(gameTypesStore.create(gameType), clients);
+
+            var gameResult = new CompletableFuture<Integer>();
+
+            var game = new OnlineTurnBasedGame(
+                    getAdmins().toArray(NettyClient[]::new),
+                    gameTypesStore.create(gameType),
+                    gameResult,
+                    turnTime,
+                    clients
+            );
+
+            var grfReturn = new GameResultFuture(game, gameResult);
 
             for (int i = 0; i < clients.length; i++) {
                 players[i] = new ServerPlayer(clients[i]);
                 clients[i].setGame(new ImmutablePair<>(game, players[i]));
             }
-            System.out.println("Starting OnlineTurnBasedGame");
 
             game.game().init(players);
             gameStore.add(game);
@@ -149,11 +167,14 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
                     clients[0].name(),
                     gameType,
                     clients[0].name()));
+
             game.start();
+            return grfReturn;
         } catch (Exception e) {
             IO.println("ERROR: Failed to start OnlineTurnBasedGame");
             e.printStackTrace();
         }
+        return null;
     }
 
     @Override
@@ -161,6 +182,10 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
         return clientStore.all().stream().toList();
     }
 
+    public List<NettyClient> getAdmins() {
+        return new ArrayList<>(admins); // Clone so the list can't be edited.
+    }
+
     @Override
     public void shutdown() {
         scheduler.shutdown();
@@ -219,7 +244,6 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
                 }
 
                 if  (userInGame) { continue; }
-                //
 
                 int first = Math.max(left, right);
                 int second = Math.min(left, right);
@@ -227,7 +251,7 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
                 userNames.remove(first);
                 userNames.remove(second);
 
-                startGame(key, getUser(userLeft), getUser(userRight));
+                startGame(key, Duration.ofSeconds(10), getUser(userLeft), getUser(userRight));
             }
         }
     }
@@ -261,4 +285,74 @@ public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
 
         return true;
     }
+
+    public void startTournament(String gameType, NettyClient requestor, boolean shuffle) {
+        if (!admins.contains(requestor)) {
+            requestor.send("ERR you do not have the privileges to start a tournament");
+            return;
+        }
+
+        var tournamentUsers = new ArrayList<>(onlineUsers());
+        tournamentUsers.removeIf(admins::contains);
+
+        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();
+
+        new Thread(() -> tournament.run(gameType)).start();
+    }
+
+    public void endTournament(List<IntegerScoreSystem> systems) {
+        if (systems.isEmpty()) return;
+
+        Map<String, List<ImmutablePair<String, Integer>>> combined = new HashMap<>();
+
+        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 namesJson = gson.toJson(names);
+        String systemNamesJson = gson.toJson(systemNames);
+        String scoresJson = gson.toJson(scores);
+
+        String msg = String.format(
+                "SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORETYPES: %s, SCORES: %s, TOURNAMENT: 1}",
+                "none", // TODO gametype
+                namesJson,
+                systemNamesJson,
+                scoresJson
+        );
+
+        for (var user : onlineUsers()) {
+            user.send(msg);
+        }
+    }
 }

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/connectionHandler/NettyClientSession.java

@@ -11,8 +11,6 @@ import org.toop.framework.networking.server.Server;
 import org.toop.framework.networking.server.client.Client;
 import org.toop.framework.networking.server.parsing.Parser;
 
-import java.util.Arrays;
-
 public class NettyClientSession extends SimpleChannelInboundHandler<String> implements ClientSession<OnlineTurnBasedGame, ServerPlayer> {
 
     private final NettyClient client;
@@ -41,13 +39,9 @@ public class NettyClientSession extends SimpleChannelInboundHandler<String> impl
     @Override
     protected void channelRead0(ChannelHandlerContext ctx, String msg) {
 
-        IO.println(msg);
-
         ParsedMessage p = Parser.parse(msg);
         if (p == null) return;
 
-        IO.println(p.command() + " " + Arrays.toString(p.args()));
-
         handler.handle(p);
     }
 

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

@@ -1,18 +1,17 @@
 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.utils.Utils;
 
 public class MessageHandler implements Handler<ParsedMessage> {
 
     private final Server server;
-    private final Client<OnlineTurnBasedGame, ServerPlayer> client;
+    private final NettyClient client;
 
-    public MessageHandler(Server server, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    public MessageHandler(Server server, NettyClient client) {
         this.server = server;
         this.client = client;
     }
@@ -28,6 +27,7 @@ public class MessageHandler implements Handler<ParsedMessage> {
             case "challenge" -> handleChallenge(message, client);
             case "message" -> handleMessage(message, client);
             case "help" -> handleHelp(message, client);
+            case "tournament" -> handleTournament(message, client);
             default -> client.send("ERROR Unknown command");
         }
     }
@@ -41,27 +41,27 @@ public class MessageHandler implements Handler<ParsedMessage> {
         return true;
     }
 
-    private void handleLogin(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    private void handleLogin(ParsedMessage p, NettyClient client) {
         if (!hasArgs(p.args())) return;
 
         client.setName(p.args()[0]);
     }
 
-    private void handleSubscribe(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    private void handleSubscribe(ParsedMessage p, NettyClient client) {
         if (!hasArgs(p.args())) return;
 
         server.subscribeClient(client.name(), p.args()[0]);
     }
 
-    private void handleHelp(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    private void handleHelp(ParsedMessage p, NettyClient client) {
         // TODO
     }
 
-    private void handleMessage(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    private void handleMessage(ParsedMessage p, NettyClient client) {
         // TODO
     }
 
-    private void handleGet(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    private void handleGet(ParsedMessage p, NettyClient client) {
         if (!hasArgs(p.args())) return;
 
         switch (p.args()[0]) {
@@ -73,10 +73,14 @@ public class MessageHandler implements Handler<ParsedMessage> {
                 var names = server.gameTypes().stream().iterator();
                 client.send("SVR GAMELIST " + Utils.returnQuotedString(names));
             }
+            case "admins" -> {
+                var names = server.getAdmins().stream().map(Client::name).iterator();
+                client.send("SVR ADMINS " + Utils.returnQuotedString(names));
+            }
         }
     }
 
-    private void handleChallenge(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    private void handleChallenge(ParsedMessage p, NettyClient client) {
         if (!hasArgs(p.args())) return;
         if (p.args().length < 2) return;
 
@@ -101,10 +105,21 @@ public class MessageHandler implements Handler<ParsedMessage> {
         server.challengeClient(client.name(), p.args()[0], p.args()[1]);
     }
 
-    private void handleMove(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+    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) {
+        if(!hasArgs(p.args())) return;
+
+        if (p.args()[0].equalsIgnoreCase("start") && p.args().length > 1) {
+            server.startTournament(p.args()[1], client, false); // TODO add shuffle to msg
+        }
     }
 }

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

@@ -0,0 +1,86 @@
+package org.toop.framework.networking.server.tournaments;
+
+import org.toop.framework.networking.server.GameResultFuture;
+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 java.time.Duration;
+import java.util.*;
+import java.util.concurrent.*;
+
+public class AsyncTournamentRunner implements TournamentRunner {
+
+    @Override
+    public void run(
+            MatchExecutor matchRunner,
+            MatchMaker matchMaker,
+            List<IntegerScoreSystem> scoreSystems,
+            ResultBroadcaster<IntegerScoreSystem> broadcaster,
+            Duration turnTime,
+            String gameType
+    ) {
+
+        ExecutorService matchExecutor = Executors.newVirtualThreadPerTaskExecutor();
+        ExecutorService scoringExecutor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+
+        Queue<TournamentMatch> pendingMatches = new ConcurrentLinkedQueue<>();
+        matchMaker.forEach(pendingMatches::add);
+
+        Set<NettyClient> busyPlayers = ConcurrentHashMap.newKeySet();
+        List<CompletableFuture<Void>> runningMatches = new CopyOnWriteArrayList<>();
+
+        try {
+            while (!pendingMatches.isEmpty() || !runningMatches.isEmpty()) {
+
+                Iterator<TournamentMatch> it = pendingMatches.iterator();
+                while (it.hasNext()) {
+                    TournamentMatch match = it.next();
+
+                    NettyClient a = match.getClient0();
+                    NettyClient b = match.getClient1();
+
+                    // TODO game != null doesn't work here, fix later
+                    if (busyPlayers.contains(a) || busyPlayers.contains(b)) {
+                        continue;
+                    }
+
+                    busyPlayers.add(a);
+                    busyPlayers.add(b);
+                    it.remove();
+
+                    CompletableFuture<Void> f =
+                            CompletableFuture.runAsync(() -> {
+                                try {
+                                    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();
+                                    busyPlayers.remove(a);
+                                    busyPlayers.remove(b);
+                                }
+                            }, matchExecutor);
+
+                    runningMatches.add(f);
+
+                    f.whenComplete((_, _) -> runningMatches.remove(f));
+                }
+
+                Thread.sleep(10); // Safety
+            }
+
+            broadcaster.broadcast(scoreSystems);
+
+        } catch (InterruptedException e) {
+            Thread.currentThread().interrupt();
+        } finally {
+            matchExecutor.shutdown();
+        }
+    }
+}

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

@@ -0,0 +1,40 @@
+package org.toop.framework.networking.server.tournaments;
+
+import org.toop.framework.networking.server.GameResultFuture;
+import org.toop.framework.networking.server.MatchExecutor;
+import org.toop.framework.networking.server.tournaments.matchmakers.MatchMaker;
+import org.toop.framework.networking.server.tournaments.scoresystems.IntegerScoreSystem;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.concurrent.*;
+
+public class BasicTournamentRunner implements TournamentRunner {
+    @Override
+    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 = matchExecutor.submit(gameType, turnTime, match.getClient0(), match.getClient1());
+                    scoreSystems.forEach(e -> e.result(match, game.result().join()));
+
+                    match.getClient0().clearGame();
+                    match.getClient1().clearGame();
+                }
+
+                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

@@ -0,0 +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.time.Duration;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
+public class Tournament {
+
+    private final MatchExecutor matchExecutor;
+    private final 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/TournamentMatch.java

@@ -0,0 +1,18 @@
+package org.toop.framework.networking.server.tournaments;
+
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.utils.ImmutablePair;
+
+public class TournamentMatch extends ImmutablePair<NettyClient, NettyClient> {
+    public TournamentMatch(NettyClient a, NettyClient b) {
+        super(a, b);
+    }
+
+    public NettyClient getClient0() {
+        return getLeft();
+    }
+
+    public NettyClient getClient1() {
+        return getRight();
+    }
+}

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

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

@@ -0,0 +1,13 @@
+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.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

@@ -0,0 +1,67 @@
+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 RoundRobinMatchMaker implements MatchMaker {
+
+    private final List<NettyClient> players = new ArrayList<>();
+
+    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);
+    }
+
+    @Override
+    public List<NettyClient> getPlayers() {
+        return players;
+    }
+
+    @Override
+    public Iterator<TournamentMatch> iterator() {
+        return new Iterator<>() {
+
+            private int i = 0;
+            private int j = 1;
+
+            @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);
+
+                j++;
+                if (j >= players.size()) {
+                    i++;
+                    j = i + 1;
+                }
+
+                return new TournamentMatch(home, away);
+            }
+        };
+    }
+}

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

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

framework/src/main/java/org/toop/framework/networking/server/tournaments/scoresystems/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

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

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

@@ -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;
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/tournaments/shufflers/RandomShuffle.java

@@ -0,0 +1,20 @@
+package org.toop.framework.networking.server.tournaments.shufflers;
+
+import java.util.List;
+import java.util.Random;
+
+public class RandomShuffle implements Shuffler {
+    @Override
+    public <T> void shuffle(List<T> listToShuffle) {
+        final int SHUFFLE_AMOUNT = listToShuffle.size() * 2;
+
+        Random rand = new Random();
+
+        for (int i = 0; i <= SHUFFLE_AMOUNT; i++) {
+            int index = rand.nextInt(listToShuffle.size());
+            T match = listToShuffle.get(index);
+            listToShuffle.remove(index);
+            listToShuffle.addLast(match);
+        }
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/tournaments/shufflers/Shuffler.java

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server.tournaments.shufflers;
+
+import java.util.List;
+
+public interface Shuffler {
+    <T> void shuffle(List<T> listToShuffle);
+}

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

@@ -0,0 +1,193 @@
+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 TurnBasedGame state;
+		public long move;
+
+		public Node parent;
+
+		public int expanded;
+		public Node[] children;
+
+		public int visits;
+		public float value;
+
+		public Node(TurnBasedGame state, long move, Node parent) {
+			this.state = state;
+			this.move = move;
+
+			this.parent = parent;
+
+			this.expanded = 0;
+			this.children = new Node[Long.bitCount(state.getLegalMoves())];
+
+			this.visits = 0;
+			this.value = 0.0f;
+		}
+
+		public Node(TurnBasedGame state) {
+			this(state, 0L, null);
+		}
+
+		public boolean isFullyExpanded() {
+			return expanded >= children.length;
+		}
+
+		float calculateUCT() {
+			float exploitation = visits <= 0? 0 : value / visits;
+			float exploration = 1.41f * (float)(Math.sqrt(Math.log(visits) / visits));
+
+			return exploitation + exploration;
+		}
+
+		public Node bestUCTChild() {
+			int bestChildIndex = -1;
+			float bestScore = Float.NEGATIVE_INFINITY;
+
+			for (int i = 0; i < expanded; i++) {
+				final float score = calculateUCT();
+
+				if (score > bestScore) {
+					bestChildIndex = i;
+					bestScore = score;
+				}
+			}
+
+			return bestChildIndex >= 0? children[bestChildIndex] : this;
+		}
+	}
+
+	private final int milliseconds;
+
+	public MCTSAI(int milliseconds) {
+		this.milliseconds = milliseconds;
+	}
+
+	public MCTSAI(MCTSAI other) {
+		this.milliseconds = other.milliseconds;
+	}
+
+	@Override
+	public MCTSAI deepCopy() {
+		return new MCTSAI(this);
+	}
+
+	@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);
+		}
+
+		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());
+	}
+
+	private Node selection(Node node) {
+		while (node.state.getLegalMoves() != 0L && node.isFullyExpanded()) {
+			node = node.bestUCTChild();
+		}
+
+		return node;
+	}
+
+	private Node expansion(Node node, long legalMoves) {
+		for (int i = 0; i < node.expanded; i++) {
+			legalMoves &= ~node.children[i].move;
+		}
+
+		if (legalMoves == 0L) {
+			return node;
+		}
+
+		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;
+			}
+
+			return -1.0f;
+		}
+
+		return -0.2f;
+	}
+
+	private void backPropagation(Node node, float value) {
+		while (node != null) {
+			node.visits++;
+			node.value += value;
+			node = node.parent;
+		}
+	}
+
+	public static long randomSetBit(long value) {
+		Random random = new Random();
+
+		int count = Long.bitCount(value);
+		int target = random.nextInt(count);
+
+		while (true) {
+			int bit = Long.numberOfTrailingZeros(value);
+			if (target == 0) {
+				return 1L << bit;
+			}
+			value &= value - 1;
+			target--;
+		}
+	}
+}

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

@@ -0,0 +1,195 @@
+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

@@ -0,0 +1,258 @@
+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/MiniMaxAI.java

@@ -1,4 +1,4 @@
-package org.toop.framework.game.players;
+package org.toop.game.players.ai;
 
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;

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

@@ -1,4 +1,4 @@
-package org.toop.framework.game.players;
+package org.toop.game.players.ai;
 
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractAI;