Removed unnecessary imports

* merge widgets with development

* readd previous game thread code

* Revert "readd previous game thread code"

This reverts commit d24feef73e.

* Revert "Merge remote-tracking branch 'origin/Development' into Development"

This reverts commit 59d46cb73c, reversing
changes made to 38681c5db0.

* Revert "merge widgets with development"

This reverts commit 38681c5db0.

* Merge 292 into development (#293)

Applied template method pattern to abstract player

* Added documentation to player classes and improved method names (#295)

* mcts v1

* bitboard optimization

* bitboard fix & mcts v2 & mcts v3. v3 still in progress and v4 coming soon

* main

---------

Co-authored-by: ramollia <>
Co-authored-by: Stef <stbuwalda@gmail.com>
Co-authored-by: Stef <48526421+StefBuwalda@users.noreply.github.com>

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

@@ -1,10 +1,14 @@
 package org.toop.app;
 
+import javafx.application.Application;
 import javafx.application.Platform;
+import javafx.geometry.Pos;
+import javafx.scene.Scene;
 import javafx.scene.input.KeyCode;
 import javafx.scene.input.KeyCodeCombination;
 import javafx.scene.input.KeyEvent;
-
+import javafx.scene.layout.StackPane;
+import javafx.stage.Stage;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.complex.LoadingWidget;
@@ -16,9 +20,8 @@ import org.toop.framework.audio.*;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.eventbus.GlobalEventBus;
-import org.toop.game.machinelearning.NeuralNetwork;
-import org.toop.framework.networking.NetworkingClientEventListener;
-import org.toop.framework.networking.NetworkingClientManager;
+import org.toop.framework.networking.connection.NetworkingClientEventListener;
+import org.toop.framework.networking.connection.NetworkingClientManager;
 import org.toop.framework.resource.ResourceLoader;
 import org.toop.framework.resource.ResourceManager;
 import org.toop.framework.resource.events.AssetLoaderEvents;
@@ -28,12 +31,6 @@ import org.toop.framework.resource.resources.SoundEffectAsset;
 import org.toop.local.AppContext;
 import org.toop.local.AppSettings;
 
-import javafx.application.Application;
-import javafx.geometry.Pos;
-import javafx.scene.Scene;
-import javafx.scene.layout.StackPane;
-import javafx.stage.Stage;
-
 import java.util.Objects;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.ExecutorService;
@@ -87,7 +84,7 @@ public final class App extends Application {
 
 		AppSettings.applySettings();
 
-		setKeybinds(root);
+        setKeybinds(root);
 
         LoadingWidget loading = new LoadingWidget(Primitive.text(
                 "Loading...", false), 0, 0, Integer.MAX_VALUE, false, false // Just set a high default
@@ -95,7 +92,7 @@ public final class App extends Application {
 
 		WidgetContainer.setCurrentView(loading);
 
-		setOnLoadingSuccess(loading);
+        setOnLoadingSuccess(loading);
 
         EventFlow loadingFlow = new EventFlow();
 
@@ -138,19 +135,12 @@ public final class App extends Application {
 		}
 
 		stage.show();
-
-        //startML();
-	}
-
-    private void startML() {
-        NeuralNetwork nn = new NeuralNetwork();
-        nn.init();
     }
 
 	private void setKeybinds(StackPane root) {
 		root.addEventHandler(KeyEvent.KEY_PRESSED,event -> {
 			if (event.getCode() == KeyCode.ESCAPE) {
-				escapePopup();
+				escapePopup();	
 			}
 		});
         stage.setFullScreenExitKeyCombination(

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

@@ -11,19 +11,18 @@ 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.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.clients.TournamentNetworkingClient;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.framework.networking.types.NetworkingConnector;
-import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
-import org.toop.game.players.ArtificialPlayer;
-import org.toop.game.players.OnlinePlayer;
-import org.toop.game.players.ai.RandomAI;
+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.networking.server.gateway.NettyGatewayServer;
+import org.toop.framework.game.players.LocalPlayer;
 import org.toop.local.AppContext;
 
+import java.util.Arrays;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 import java.util.concurrent.Executors;
@@ -32,7 +31,8 @@ import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public final class Server {
-    // TODO: Keep track of listeners. Remove them on Server connection close so reference is deleted.
+	private NettyGatewayServer nettyGatewayServer;
+
 	private String user = "";
 	private long clientId = -1;
 
@@ -60,10 +60,13 @@ public final class Server {
 		return null;
 	}
 
+	public Server(String ip, String port, String user) {
+		this(ip, port, user, null);
+	}
 
     // Server has to deal with ALL network related listen events. This "server" can then interact with the manager to make stuff happen.
     // This prevents data races where events get sent to the game manager but the manager isn't ready yet.
-	public Server(String ip, String port, String user) {
+	public Server(String ip, String port, String user, NettyGatewayServer nettyGatewayServer) {
 		if (ip.split("\\.").length < 4) {
 			new ErrorPopup("\"" + ip + "\" " + AppContext.getString("is-not-a-valid-ip-address"));
 			return;
@@ -83,6 +86,8 @@ public final class Server {
 			return;
 		}
 
+		this.nettyGatewayServer = nettyGatewayServer;
+
 		final int reconnectAttempts = 10;
 
 		LoadingWidget loading = new LoadingWidget(
@@ -113,7 +118,8 @@ public final class Server {
 				return;
 			}
 
-			primary = new ServerView(user, this::sendChallenge);
+			primary = new ServerView(user, this::sendChallenge, user, clientId);
+
 			WidgetContainer.getCurrentView().transitionNextCustom(primary, "disconnect", this::disconnect);
 
 			a.unsubscribe("connecting");
@@ -154,7 +160,9 @@ public final class Server {
                 .listen(NetworkEvents.GameMatchResponse.class, this::handleMatchResponse, false, "match-response")
                 .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.YourTurnResponse.class, this::handleYourTurn, false, "your-turn")
+				.listen(NetworkEvents.ClosedConnection.class, this::closedConnection, false, "closed-connection")
+                .listen(NetworkEvents.TournamentResultResponse.class, this::handleTournamentResult, false, "tournament-result");
 
 		connectFlow = a;
 	}
@@ -178,7 +186,7 @@ public final class Server {
 
         gameController = null;
 
-        //if (!isPolling) return;
+//        if (!isPolling) return;
 
         String gameType = extractQuotedValue(response.gameType());
         if (response.clientId() == clientId) {
@@ -191,45 +199,29 @@ 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 LocalPlayer(user);
+            players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
 
             switch (type) {
-                case TICTACTOE ->{
-                        Player<BitboardTicTacToe>[] players = new Player[2];
-                        players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
-                        players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), user);
-                        gameController = new TicTacToeBitController(players);
-                }
-                case REVERSI -> {
-                    Player<BitboardReversi>[] players = new Player[2];
-                    players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
-                    players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), user);
-                    gameController = new ReversiBitController(players);}
+                case TICTACTOE -> gameController = new TicTacToeBitController(players);
+                case REVERSI -> gameController = new ReversiBitController(players);
                 default -> new ErrorPopup("Unsupported game type.");
 
             }
 
-            if (gameController != null){
+            if (gameController != null) {
+				primary.reEnableButton(); // Re enable subscribe button
                 gameController.start();
+				isPolling = true; // Fixes server getting stuck
             }
         }
     }
@@ -249,6 +241,12 @@ 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.scores()));
+    }
+
     private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
         if (gameController == null) {
             return;
@@ -263,7 +261,7 @@ public final class Server {
 		String gameType = extractQuotedValue(response.gameType());
 		final String finalGameType = gameType;
 		var a = new ChallengePopup(challengerName, gameType, (playerInformation) -> {
-			final int challengeId = Integer.parseInt(response.challengeId().replaceAll("\\D", ""));
+			final long challengeId = Long.parseLong(response.challengeId().replaceAll("\\D", ""));
 			new EventFlow().addPostEvent(new NetworkEvents.SendAcceptChallenge(clientId, challengeId)).postEvent();
             isSingleGame.set(true);
 		});
@@ -281,9 +279,27 @@ public final class Server {
 		stopScheduler();
 		connectFlow.unsubscribeAll();
 
+		if (nettyGatewayServer != null) {
+			nettyGatewayServer.stop();
+		}
+
 		WidgetContainer.getCurrentView().transitionPrevious();
 	}
 
+	private void closedConnection(NetworkEvents.ClosedConnection e) {
+		new EventFlow().addPostEvent(new NetworkEvents.CloseClient(clientId)).postEvent();
+		isPolling = false;
+		stopScheduler();
+		connectFlow.unsubscribeAll();
+
+		if (nettyGatewayServer != null) {
+			nettyGatewayServer.stop();
+		}
+
+		WidgetContainer.getCurrentView().transitionPrevious();
+		WidgetContainer.add(Pos.CENTER, new ErrorPopup("Server closed connection."));
+	}
+
 	private void forfeitGame() {
 		new EventFlow().addPostEvent(new NetworkEvents.SendForfeit(clientId)).postEvent();
 	}
@@ -330,7 +346,10 @@ public final class Server {
 
 	private void gamesListFromServerHandler(NetworkEvents.GamelistResponse event) {
 		gameList.clear();
-		gameList.addAll(List.of(event.gamelist()));
+		var gl = new java.util.ArrayList<>(List.of(event.gamelist()));
+        gl.sort(String::compareTo);
+		gameList.addAll(gl);
+		primary.updateGameList(gl);
 	}
 
 	public void populateGameList() {

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

@@ -14,7 +14,7 @@ import org.toop.framework.gameFramework.view.GUIEvents;
 
 import java.util.function.Consumer;
 
-public abstract class BitGameCanvas<T extends TurnBasedGame<T>> implements GameCanvas<T> {
+public abstract class BitGameCanvas implements GameCanvas {
 	protected record Cell(float x, float y, float width, float height) {
 		public boolean isInside(double x, double y) {
 			return x >= this.x && x <= this.x + width &&
@@ -78,6 +78,7 @@ public abstract class BitGameCanvas<T extends TurnBasedGame<T>> implements GameC
 		}
 
 		canvas.setOnMouseClicked(event -> {
+
 			if (event.getButton() != MouseButton.PRIMARY) {
 				return;
 			}
@@ -93,9 +94,6 @@ public abstract class BitGameCanvas<T extends TurnBasedGame<T>> implements GameC
 			}
 		});
 
-
-
-
 		render();
 	}
 

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

@@ -3,6 +3,7 @@ package org.toop.app.canvas;
 import javafx.scene.canvas.Canvas;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-public interface GameCanvas<T extends TurnBasedGame<T>> extends GameDrawer<T>{
+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<T extends TurnBasedGame<T>> {
-    void redraw(T gameCopy);
-}

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

@@ -2,12 +2,9 @@ package org.toop.app.canvas;
 
 import javafx.scene.paint.Color;
 import org.toop.app.App;
-import org.toop.game.games.reversi.BitboardReversi;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-import java.util.Arrays;
-import java.util.function.Consumer;
-
-public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> {
+public class ReversiBitCanvas extends BitGameCanvas {
     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 -> {
@@ -33,7 +30,7 @@ public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> {
     }
 
     @Override
-    public void redraw(BitboardReversi gameCopy) {
+    public void redraw(TurnBasedGame gameCopy) {
         clearAll();
         long[] board = gameCopy.getBoard();
         loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));

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

@@ -2,12 +2,9 @@ package org.toop.app.canvas;
 
 import javafx.scene.paint.Color;
 import org.toop.app.App;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-import java.util.Arrays;
-import java.util.function.Consumer;
-
-public class TicTacToeBitCanvas extends BitGameCanvas<BitboardTicTacToe>{
+public class TicTacToeBitCanvas extends BitGameCanvas{
     public TicTacToeBitCanvas() {
         super(
                 Color.GRAY,
@@ -22,7 +19,7 @@ public class TicTacToeBitCanvas extends BitGameCanvas<BitboardTicTacToe>{
     }
 
     @Override
-    public void redraw(BitboardTicTacToe gameCopy) {
+    public void redraw(TurnBasedGame gameCopy) {
         clearAll();
         drawMoves(gameCopy.getBoard());
     }

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

@@ -10,15 +10,15 @@ 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;
 import org.toop.framework.gameFramework.view.GUIEvents;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.players.LocalPlayer;
+import org.toop.framework.networking.connection.events.NetworkEvents;
+import org.toop.framework.game.players.LocalPlayer;
 
-public class GenericGameController<T extends TurnBasedGame<T>> implements GameController {
+public class GenericGameController implements GameController {
     protected final EventFlow eventFlow = new EventFlow();
 
     // Logger for logging
@@ -28,21 +28,23 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
     protected final GameView gameView;
 
     // Reference to game canvas
-    protected final GameCanvas<T> canvas;
+    protected final GameCanvas canvas;
 
-    protected final TurnBasedGame<T> game;       // Reference to game instance
+    protected final TurnBasedGame game;       // Reference to game instance
     private final ThreadBehaviour gameThreadBehaviour;
 
     // TODO: Change gameType to automatically happen with either dependency injection or something else.
-    public GenericGameController(GameCanvas<T> canvas, T game, ThreadBehaviour gameThreadBehaviour, String gameType) {
-        logger.info("Creating: " + this.getClass());
+    public GenericGameController(GameCanvas canvas, TurnBasedGame game, ThreadBehaviour gameThreadBehaviour, String gameType) {
+        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,24 +55,40 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         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<T> lp){lp.setLastMove(event.move());}}, false);
+                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {
+                    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<T> getCurrentPlayer(){
+    public Player getCurrentPlayer(){
         return game.getPlayer(getCurrentPlayerIndex());
     }
 
@@ -91,14 +109,14 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
     }
 
     private void onGameFinish(GUIEvents.GameEnded event){
-        logger.info("Game Finished");
+        logger.info("OnlineTurnBasedGame Finished");
         String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
         gameView.gameOver(event.winOrTie(), name);
         stop();
     }
 
-    public Player<T> getPlayer(int player){
-        if (player < 0 || player >= 2){ // TODO: Make game turn player count
+    public Player getPlayer(int player){
+        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");
         }

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

@@ -3,20 +3,21 @@ package org.toop.app.gameControllers;
 import org.toop.app.canvas.ReversiBitCanvas;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.gameThreads.LocalThreadBehaviour;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.players.OnlinePlayer;
+import org.toop.framework.game.gameThreads.LocalThreadBehaviour;
+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 = Arrays.stream(players).anyMatch(e -> e instanceof OnlinePlayer) ?
+                new OnlineThreadBehaviour(game) : new LocalThreadBehaviour(game);
 
-public class ReversiBitController extends GenericGameController<BitboardReversi> {
-    public ReversiBitController(Player<BitboardReversi>[] players) {
-        BitboardReversi game = new BitboardReversi(players);
-        ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
-        for (Player<BitboardReversi> player : players) {
-            if (player instanceof OnlinePlayer<BitboardReversi>){
-                thread = new OnlineThreadBehaviour<>(game);
-            }
-        }
         super(new ReversiBitCanvas(), game, thread, "Reversi");
     }
 }

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

@@ -3,21 +3,21 @@ package org.toop.app.gameControllers;
 import org.toop.app.canvas.TicTacToeBitCanvas;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.gameThreads.LocalFixedRateThreadBehaviour;
-import org.toop.game.gameThreads.LocalThreadBehaviour;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
-import org.toop.game.players.OnlinePlayer;
+import org.toop.framework.game.gameThreads.LocalThreadBehaviour;
+import org.toop.framework.game.gameThreads.OnlineThreadBehaviour;
+import org.toop.framework.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.framework.game.players.OnlinePlayer;
 
-public class TicTacToeBitController extends GenericGameController<BitboardTicTacToe> {
-    public TicTacToeBitController(Player<BitboardTicTacToe>[] players) {
-        BitboardTicTacToe game = new BitboardTicTacToe(players);
-        ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
-        for (Player<BitboardTicTacToe> player : players) {
-            if (player instanceof OnlinePlayer<BitboardTicTacToe>){
-                thread = new OnlineThreadBehaviour<>(game);
-            }
-        }
-        super(new TicTacToeBitCanvas(), game, thread , "TicTacToe");
+import java.util.Arrays;
+
+public class TicTacToeBitController extends GenericGameController {
+    public TicTacToeBitController(Player[] players) {
+        BitboardTicTacToe game = new BitboardTicTacToe();
+        game.init(players);
+
+        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/Primitive.java

@@ -64,7 +64,7 @@ public final class Primitive {
         return imageView;
     }
 
-	public static Button button(String key, Runnable onAction, boolean localize) {
+	public static Button button(String key, Runnable onAction, boolean localize, boolean disableOnClick) {
 		var button = new Button();
 		button.getStyleClass().add("button");
 
@@ -75,6 +75,7 @@ public final class Primitive {
 
 		if (onAction != null) {
 			button.setOnAction(_ -> {
+				if (disableOnClick) button.setDisable(true);
                 onAction.run();
                 playButtonSound();
             });
@@ -83,8 +84,8 @@ public final class Primitive {
 		return button;
 	}
 
-	public static Button button(String key, Runnable onAction) {
-		return button(key, onAction, true);
+	public static Button button(String key, Runnable onAction, boolean disableOnClick) {
+		return button(key, onAction, true, disableOnClick);
 	}
 
 	public static TextField input(String promptKey, String text, Consumer<String> onValueChanged, boolean localize) {

app/src/main/java/org/toop/app/widget/complex/ConfirmWidget.java

@@ -26,7 +26,7 @@ public class ConfirmWidget implements Widget {
 
 	public void addButton(String key, Runnable onClick) {
 		Platform.runLater(() -> {
-			var button = Primitive.button(key, onClick);
+			var button = Primitive.button(key, onClick, false);
 			buttonsContainer.getChildren().add(button);
 		});
 	}

app/src/main/java/org/toop/app/widget/complex/PlayerInfoWidget.java

@@ -91,7 +91,7 @@ public class PlayerInfoWidget {
             information.computerDifficulty = depth;
             information.computerThinkTime = thinktime;
             this.playerName.setText(getName(name));
-        });
+        }, false);
     }
 
     private String getName(String name) {

app/src/main/java/org/toop/app/widget/complex/TableWidget.java

@@ -0,0 +1,61 @@
+package org.toop.app.widget.complex;
+
+import javafx.collections.FXCollections;
+import javafx.collections.ObservableList;
+import javafx.geometry.Pos;
+import javafx.scene.control.TableColumn;
+import javafx.scene.control.TableView;
+import javafx.scene.control.cell.PropertyValueFactory;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class TableWidget<DATATYPE> extends PopupWidget {
+    private ObservableList<DATATYPE> serverList = FXCollections.observableArrayList();
+    private TableView<DATATYPE> table = new TableView<>();
+
+
+    public TableWidget(String... columns) {
+        var cols = new ArrayList<TableColumn<DATATYPE, String>>();
+
+        for (String column : columns) {
+            TableColumn<DATATYPE, String> col = new TableColumn<>(column.toUpperCase());
+            col.setCellValueFactory(new PropertyValueFactory<>(column));
+            cols.add(col);
+        }
+
+        table.getColumns().addAll(cols);
+        update();
+        onColumnClicked();
+
+        add(Pos.CENTER, table);
+    }
+
+    public void add(DATATYPE serverFound) {
+        serverList.add(serverFound);
+        update();
+    }
+
+    public void add(List<DATATYPE> serverFound) {
+        serverList.addAll(serverFound);
+    }
+
+    public void remove(DATATYPE serverFound) {
+        serverList.remove(serverFound);
+        update();
+    }
+
+    public void onColumnClicked() {
+        table.setOnMouseClicked(event -> {
+            DATATYPE selected = table.getSelectionModel().getSelectedItem();
+            if (selected == null) return;
+            IO.println(selected.toString());
+        });
+    }
+
+    private void update() {
+        table.setItems(serverList);
+    }
+
+
+}

app/src/main/java/org/toop/app/widget/complex/ViewWidget.java

@@ -32,7 +32,7 @@ public abstract class ViewWidget extends StackWidget {
 
 		var backButton = Primitive.button("back", () -> {
 			view.transitionPrevious();
-		});
+		}, false);
 
 		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(backButton));
 	}
@@ -45,7 +45,7 @@ public abstract class ViewWidget extends StackWidget {
 		var customButton = Primitive.button(key, () -> {
 			runnable.run();
 			view.transitionPrevious();
-		});
+		}, false);
 
 		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(customButton));
 	}
@@ -97,7 +97,7 @@ public abstract class ViewWidget extends StackWidget {
 
 		var backButton = Primitive.button("back", () -> {
 			view.transitionPrevious();
-		});
+		}, false);
 
 		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(backButton));
 	}

app/src/main/java/org/toop/app/widget/popup/ChallengePopup.java

@@ -37,8 +37,8 @@ public final class ChallengePopup extends PopupWidget {
 		var acceptButton = Primitive.button("accept", () -> {
 			onAccept.accept(playerInformation);
 			this.hide();
-		});
-		var denyButton = Primitive.button("deny", () -> hide());
+		}, false);
+		var denyButton = Primitive.button("deny", () -> hide(), false);
 
 		var leftSection = Primitive.vbox(
 			challengeText,

app/src/main/java/org/toop/app/widget/popup/EscapePopup.java

@@ -18,13 +18,13 @@ public class EscapePopup extends PopupWidget {
         ViewWidget currentView = WidgetContainer.getCurrentView();
         ArrayList<Node> nodes = new ArrayList<>();
 
-        nodes.add(Primitive.button("Continue", this::hide, false)); // TODO, localize
+        nodes.add(Primitive.button("Continue", this::hide, false, false)); // TODO, localize
 
         if (!(currentView.getClass().isAssignableFrom(OptionsView.class))) {
             var opt = Primitive.button("options", () -> {
                 hide();
                 WidgetContainer.getCurrentView().transitionNext(new OptionsView());
-            });
+            }, false);
             nodes.add(opt);
         }
 
@@ -33,14 +33,14 @@ public class EscapePopup extends PopupWidget {
             if (tut != null) {
                 nodes.add(Primitive.button("tutorialstring", () -> {
                     WidgetContainer.getCurrentView().add(Pos.CENTER, tut);
-                }));
+                }, false));
             }
         }
 
         nodes.add(Primitive.button("quit", () -> {
             hide();
             WidgetContainer.add(Pos.CENTER, new QuitPopup());
-        }));
+        }, false));
 
         add(Pos.CENTER, Primitive.vbox(nodes.toArray(new Node[0])));
 

app/src/main/java/org/toop/app/widget/popup/SendChallengePopup.java

@@ -62,9 +62,9 @@ public final class SendChallengePopup extends PopupWidget {
 		var sendButton = Primitive.button(
 			"send",
 			() -> { onSend.accept(playerInformation, gameChoice.getValue()); this.hide(); }
-		);
+		, false);
 
-		var cancelButton = Primitive.button("cancel", () -> hide());
+		var cancelButton = Primitive.button("cancel", () -> hide(), false);
 
 		var leftSection = Primitive.vbox(
 			challengeText,

app/src/main/java/org/toop/app/widget/tutorial/BaseTutorialWidget.java

@@ -47,8 +47,8 @@ public class BaseTutorialWidget extends PopupWidget implements Updatable {
         this.pages = pages;
         this.nextScreen = nextScreen;
 
-        previousButton = Primitive.button("goback", () -> { update(false); this.hide(); });
-        nextButton = Primitive.button(">", () -> update(true));
+        previousButton = Primitive.button("goback", () -> { update(false); this.hide(); }, false);
+        nextButton = Primitive.button(">", () -> update(true), false);
 
         var w = Primitive.hbox(
                 previousButton,

app/src/main/java/org/toop/app/widget/tutorial/ShowEnableTutorialWidget.java

@@ -10,9 +10,9 @@ public class ShowEnableTutorialWidget extends PopupWidget {
 
     public ShowEnableTutorialWidget(Runnable tutorial, Runnable nextScreen, Runnable appSettingsSetter) {
         var a = Primitive.hbox(
-                Primitive.button("ok", () -> { appSettingsSetter.run(); tutorial.run(); this.hide(); }),
-                Primitive.button("no", () -> { appSettingsSetter.run(); nextScreen.run(); this.hide(); }),
-                Primitive.button("never", () -> { AppSettings.getSettings().setTutorialFlag(false); nextScreen.run(); this.hide(); })
+                Primitive.button("ok", () -> { appSettingsSetter.run(); tutorial.run(); this.hide(); }, false),
+                Primitive.button("no", () -> { appSettingsSetter.run(); nextScreen.run(); this.hide(); }, false),
+                Primitive.button("never", () -> { AppSettings.getSettings().setTutorialFlag(false); nextScreen.run(); this.hide(); }, false)
         );
 
         var txt = Primitive.text("tutorial");

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

@@ -40,7 +40,7 @@ public final class GameView extends ViewWidget {
         player2Icon = new Circle();
 
 		if (onForfeit != null) {
-			forfeitButton = Primitive.button("forfeit", () -> onForfeit.run());
+			forfeitButton = Primitive.button("forfeit", () -> onForfeit.run(), false);
 		} else {
 			forfeitButton = null;
 		}
@@ -48,7 +48,7 @@ public final class GameView extends ViewWidget {
 		exitButton = Primitive.button("exit", () -> {
 			onExit.run();
 			transitionPrevious();
-		});
+		}, false);
 
 		if (onMessage != null) {
 			chatInput = Primitive.input("enter-your-message", "", null);

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.game.games.reversi.BitboardReversi;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
-import org.toop.game.players.ArtificialPlayer;
-import org.toop.game.players.LocalPlayer;
+import org.toop.framework.game.players.ArtificialPlayer;
 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.LocalPlayer;
+import org.toop.game.players.ai.MCTSAI;
+import org.toop.game.players.ai.MCTSAI2;
+import org.toop.game.players.ai.MCTSAI3;
 import org.toop.game.players.ai.MiniMaxAI;
-import org.toop.game.players.ai.RandomAI;
 import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
@@ -52,14 +52,14 @@ public class LocalMultiplayerView extends ViewWidget {
 			switch (information.type) {
                 case TICTACTOE:
                     if (information.players[0].isHuman) {
-                        players[0] = new LocalPlayer<>(information.players[0].name);
+                        players[0] = new LocalPlayer(information.players[0].name);
                     } else {
-                        players[0] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), "Random AI");
+                        players[0] = new ArtificialPlayer(new MCTSAI(100), "MCTS AI");
                     }
                     if (information.players[1].isHuman) {
-                        players[1] = new LocalPlayer<>(information.players[1].name);
+                        players[1] = new LocalPlayer(information.players[1].name);
                     } else {
-                        players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardTicTacToe>(9), "MiniMax AI");
+                        players[1] = new ArtificialPlayer(new MiniMaxAI(9), "MiniMax AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
                         new ShowEnableTutorialWidget(
@@ -80,14 +80,15 @@ public class LocalMultiplayerView extends ViewWidget {
                     break;
                 case REVERSI:
                     if (information.players[0].isHuman) {
-                        players[0] = new LocalPlayer<>(information.players[0].name);
+                        players[0] = new LocalPlayer(information.players[0].name);
                     } else {
-                        players[0] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), "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);
+                        players[1] = new LocalPlayer(information.players[1].name);
                     } else {
-                        players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardReversi>(6), "MiniMax");
+						players[1] = new ArtificialPlayer(new MCTSAI2(50), "MCTS V2 AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(
@@ -107,7 +108,7 @@ public class LocalMultiplayerView extends ViewWidget {
                     }
                     break;
             }
-        });
+        }, false);
 
 		var playerSection = setupPlayerSections();
 

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

@@ -10,11 +10,11 @@ public class LocalView extends ViewWidget {
 	public LocalView() {
 		var ticTacToeButton = Primitive.button("tic-tac-toe", () -> {
 			transitionNext(new LocalMultiplayerView(GameInformation.Type.TICTACTOE));
-		});
+		}, false);
 
 		var reversiButton = Primitive.button("reversi", () -> {
 			transitionNext(new LocalMultiplayerView(GameInformation.Type.REVERSI));
-		});
+		}, false);
 
 		add(Pos.CENTER, Primitive.vbox(
 			ticTacToeButton,

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

@@ -9,24 +9,24 @@ public class MainView extends ViewWidget {
 	public MainView() {
 		var localButton = Primitive.button("local", () -> {
 			transitionNext(new LocalView());
-		});
+		}, false);
 
 		var onlineButton = Primitive.button("online", () -> {
 			transitionNext(new OnlineView());
-		});
+		}, false);
 
 		var creditsButton = Primitive.button("credits", () -> {
 			transitionNext(new CreditsView());
-		});
+		}, false);
 
 		var optionsButton = Primitive.button("options", () -> {
 			transitionNext(new OptionsView());
-		});
+		}, false);
 
 		var quitButton = Primitive.button("quit", () -> {
 			var a = new QuitPopup();
 			a.show(Pos.CENTER);
-		});
+		}, false);
 
 		add(Pos.CENTER, Primitive.vbox(
 			localButton,

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

@@ -6,6 +6,14 @@ import org.toop.app.widget.complex.LabeledInputWidget;
 import org.toop.app.widget.complex.ViewWidget;
 
 import javafx.geometry.Pos;
+import org.toop.framework.game.games.reversi.BitboardReversi;
+import org.toop.framework.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.networking.server.gateway.NettyGatewayServer;
+import org.toop.framework.networking.server.stores.TurnBasedGameTypeStore;
+
+import java.time.Duration;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class OnlineView extends ViewWidget {
 	public OnlineView() {
@@ -21,7 +29,31 @@ public class OnlineView extends ViewWidget {
 				serverPortInput.getValue(),
 				playerNameInput.getValue()
 			);
-		});
+		}, false);
+
+		var localHostButton = Primitive.button("host!", () -> {
+
+			var tps = new TurnBasedGameTypeStore();
+			tps.register("tic-tac-toe", BitboardTicTacToe::new);
+			tps.register("reversi", BitboardReversi::new);
+
+			var a = new NettyGatewayServer(6666, tps, Duration.ofSeconds(10));
+
+			new Thread(() -> {
+				try {
+					a.start();
+				} catch (InterruptedException e) {
+					throw new RuntimeException(e);
+				}
+			}).start();
+
+			new Server(
+					"127.0.0.1",
+					"6666",
+					"host",
+					a
+			);
+		}, false, false);
 
 		add(Pos.CENTER, Primitive.vbox(
 			serverInformationHeader,
@@ -32,7 +64,9 @@ public class OnlineView extends ViewWidget {
 			playerNameInput.getNode(),
 			Primitive.separator(),
 
-			connectButton
+			connectButton,
+			Primitive.separator(),
+			localHostButton
 		));
 	}
 }

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

@@ -1,45 +1,84 @@
 package org.toop.app.widget.view;
 
+import javafx.collections.FXCollections;
+import javafx.css.converter.StringConverter;
+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;
 
 import javafx.application.Platform;
 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 {
 	private final String user;
 	private final Consumer<String> onPlayerClicked;
+	private final long clientId;
 
+	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) {
+	public ServerView(String user, Consumer<String> onPlayerClicked, String userName, long clientId) {
 		this.user = user;
 		this.onPlayerClicked = onPlayerClicked;
+		this.clientId = clientId;
 
+		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, gameListSub.getValue())).postEvent(),
+				false,
+				true
+		); // TODO localize
+
+		var subscribe = Primitive.hbox(gameListSub, subscribeButton);
+
 		var playerListSection = Primitive.vbox(
 			playerHeader,
 			Primitive.separator(),
+			subscribe,
 			listView
 		);
 
 		add(Pos.CENTER, playerListSection);
 
-		var disconnectButton = Primitive.button("disconnect", () -> {
-			transitionPrevious();
-		});
+        if (userName.equals("host")) {
+            var tournamentButton = Primitive.hbox(
+                    gameListTour,
+                    Primitive.button(
+                            "tournament",
+                            () -> GlobalEventBus.get().post(new NetworkEvents.SendCommand(clientId, "tournament", "start", gameListTour.getValue())),
+                            false,
+                            false
+                    )
+            );
+
+            add(Pos.BOTTOM_CENTER, tournamentButton);
+        }
+
+		var disconnectButton = Primitive.button(
+				"disconnect", () -> transitionPrevious(), false);
 
 		add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
 	}
@@ -49,9 +88,25 @@ public final class ServerView extends ViewWidget {
 			listView.getItems().clear();
 
 			for (String player : players) {
-				var playerButton = Primitive.button(player, () -> onPlayerClicked.accept(player), false);
+				var playerButton = Primitive.button(player, () -> onPlayerClicked.accept(player), false, false);
 				listView.getItems().add(playerButton);
 			}
 		});
 	}
+
+	public void updateGameList(List<String> games) {
+		Platform.runLater(() -> {
+			gameListSub.getItems().clear();
+			gameListSub.setItems(FXCollections.observableArrayList(games));
+			gameListSub.getSelectionModel().select(0);
+
+            gameListTour.getItems().clear();
+            gameListTour.setItems(FXCollections.observableArrayList(games));
+            gameListTour.getSelectionModel().select(0);
+		});
+	}
+
+	public void reEnableButton() {
+		subscribeButton.setDisable(false);
+	}
 }

framework/pom.xml

@@ -146,14 +146,7 @@
             <artifactId>error_prone_annotations</artifactId>
             <version>2.42.0</version>
         </dependency>
-        <dependency>
-            <groupId>org.deeplearning4j</groupId>
-            <artifactId>deeplearning4j-nn</artifactId>
-            <version>1.0.0-M2.1</version>
-            <scope>compile</scope>
-        </dependency>
-    </dependencies>
-
+	</dependencies>
 	<build>
 		<plugins>
 			<plugin>

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,40 +1,57 @@
-package org.toop.game;
+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;
 
 import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicInteger;
 
 // There is AI performance to be gained by getting rid of non-primitives and thus speeding up deepCopy
-public abstract class BitboardGame<T extends BitboardGame<T>> implements TurnBasedGame<T> {
+public abstract class BitboardGame implements TurnBasedGame {
 	private final int columnSize;
 	private final int rowSize;
 
-    private Player<T>[] players;
+	protected PlayResult state;
+
+    private Player[] players;
 
 	// long is 64 bits. Every game has a limit of 64 cells maximum.
 	private final long[] playerBitboard;
 	private int currentTurn = 0;
+	private final int playerCount;
 
-	public BitboardGame(int columnSize, int rowSize, int playerCount, Player<T>[] players) {
+	public BitboardGame(int columnSize, int rowSize, int playerCount) {
 		this.columnSize = columnSize;
 		this.rowSize = rowSize;
-        this.players = players;
+        this.playerCount = playerCount;
+		this.state = new PlayResult(GameState.NORMAL, -1);
+
 		this.playerBitboard = new long[playerCount];
 
 		Arrays.fill(playerBitboard, 0L);
 	}
 
-	public BitboardGame(BitboardGame<T> other) {
+    @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<T>::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() {
@@ -61,7 +78,7 @@ public abstract class BitboardGame<T extends BitboardGame<T>> implements TurnBas
 		return getCurrentPlayerIndex();
 	}
 
-    public Player<T> getPlayer(int index) {return players[index];}
+    public Player getPlayer(int index) {return players[index];}
 
 	public int getCurrentPlayerIndex() {
         return currentTurn % playerBitboard.length;
@@ -71,13 +88,21 @@ public abstract class BitboardGame<T extends BitboardGame<T>> implements TurnBas
 		return (currentTurn + 1) % playerBitboard.length;
 	}
 
-    public Player<T> getCurrentPlayer(){
+    public Player getCurrentPlayer(){
         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/Move.java

@@ -1,3 +1,3 @@
-package org.toop.game;
+package org.toop.framework.game;
 // TODO: Remove this, only used in ReversiCanvas. Needs to not
 public record Move(int position, char value) {}

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

@@ -1,4 +1,4 @@
-package org.toop.game.gameThreads;
+package org.toop.framework.game.gameThreads;
 
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.gameFramework.GameState;
@@ -16,7 +16,7 @@ import java.util.function.Consumer;
  * Runs a separate thread that executes game turns at a fixed frequency (default 60 updates/sec),
  * applying player moves, updating the game state, and dispatching UI events.
  */
-public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements Runnable {
+public class LocalFixedRateThreadBehaviour extends AbstractThreadBehaviour implements Runnable {
 
 
     /**
@@ -24,7 +24,7 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
      *
      * @param game    the game instance
      */
-    public LocalFixedRateThreadBehaviour(T game) {
+    public LocalFixedRateThreadBehaviour(TurnBasedGame game) {
         super(game);
     }
 
@@ -59,7 +59,7 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
             if (now >= nextUpdate) {
                 nextUpdate += UPDATE_INTERVAL;
 
-                Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
+                Player currentPlayer = game.getPlayer(game.getCurrentTurn());
                 long move = currentPlayer.getMove(game.deepCopy());
                 PlayResult result = game.play(move);
 

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

@@ -1,4 +1,4 @@
-package org.toop.game.gameThreads;
+package org.toop.framework.game.gameThreads;
 
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.gameFramework.model.game.threadBehaviour.AbstractThreadBehaviour;
@@ -16,14 +16,14 @@ import java.util.function.Consumer;
  * Repeatedly gets the current player's move, applies it to the game,
  * updates the UI, and stops when the game ends or {@link #stop()} is called.
  */
-public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements Runnable {
+public class LocalThreadBehaviour extends AbstractThreadBehaviour implements Runnable {
 
     /**
      * Creates a new behaviour for a local turn-based game.
      *
      * @param game    the game instance
      */
-    public LocalThreadBehaviour(T game) {
+    public LocalThreadBehaviour(TurnBasedGame game) {
         super(game);
     }
 
@@ -48,7 +48,7 @@ public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractTh
     @Override
     public void run() {
         while (isRunning.get()) {
-            Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
+            Player currentPlayer = game.getPlayer(game.getCurrentTurn());
             long move = currentPlayer.getMove(game.deepCopy());
             PlayResult result = game.play(move);
 

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

@@ -1,12 +1,15 @@
-package org.toop.game.gameThreads;
+package org.toop.framework.game.gameThreads;
 
 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.game.players.OnlinePlayer;
+import org.toop.framework.game.players.OnlinePlayer;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 /**
  * Handles online multiplayer game logic.
@@ -14,17 +17,20 @@ import org.toop.game.players.OnlinePlayer;
  * Reacts to server events, sending moves and updating the game state
  * for the local player while receiving moves from other players.
  */
-public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements SupportsOnlinePlay {
+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.
      */
-    public OnlineThreadBehaviour(T game) {
+    public OnlineThreadBehaviour(TurnBasedGame game) {
         super(game);
     }
 
     /** Finds the first non-online player in the array. */
-    private int getFirstNotOnlinePlayer(Player<T>[] players) {
+    private int getFirstNotOnlinePlayer(Player[] players) {
         for (int i = 0; i < players.length; i++) {
             if (!(players[i] instanceof OnlinePlayer)) {
                 return i;
@@ -51,8 +57,30 @@ public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractT
      */
     @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/OnlineWithSleepThreadBehaviour.java

@@ -1,7 +1,6 @@
-package org.toop.game.gameThreads;
+package org.toop.framework.game.gameThreads;
 
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.networking.events.NetworkEvents;
 
 /**
  * Online thread behaviour that adds a fixed delay before processing
@@ -10,14 +9,14 @@ import org.toop.framework.networking.events.NetworkEvents;
  * This is identical to {@link OnlineThreadBehaviour}, but inserts a
  * short sleep before delegating to the base implementation.
  */
-public class OnlineWithSleepThreadBehaviour<T extends TurnBasedGame<T>> extends OnlineThreadBehaviour<T> {
+public class OnlineWithSleepThreadBehaviour extends OnlineThreadBehaviour {
 
     /**
      * Creates the behaviour and forwards the players to the base class.
      *
      * @param game the online-capable turn-based game
      */
-    public OnlineWithSleepThreadBehaviour(T game) {
+    public OnlineWithSleepThreadBehaviour(TurnBasedGame game) {
         super(game);
     }
 

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

@@ -0,0 +1,82 @@
+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.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;
+    /**
+     * 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) {
+        this.onPlayerMove = onPlayerMove;
+        this.onGameEnd = onGameEnd;
+        super(game);
+    }
+
+    private void notifyPlayerMove(ImmutablePair<String, Integer> pair) {
+        if (onPlayerMove != null) {
+            onPlayerMove.accept(pair);
+        }
+    }
+
+    private void notifyGameEnd(ImmutablePair<GameState, Integer> pair) {
+        if (onGameEnd != null) {
+            onGameEnd.accept(pair);
+        }
+    }
+
+    /** Starts the game loop in a new thread. */
+    @Override
+    public void start() {
+        if (isRunning.compareAndSet(false, true)) {
+            new Thread(this).start();
+        }
+    }
+
+    /** Stops the game loop after the current iteration. */
+    @Override
+    public void stop() {
+        isRunning.set(false);
+    }
+
+    @Override
+    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)));
+
+            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);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,328 @@
+package org.toop.framework.game.games.reversi;
+
+import org.toop.framework.game.BitboardGame;
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.framework.game.BitboardGame;
+
+public class BitboardReversi extends BitboardGame {
+
+    public record Score(int black, int white) {}
+
+	private final long notAFile = 0xfefefefefefefefeL;
+	private final long notHFile = 0x7f7f7f7f7f7f7f7fL;
+
+	public BitboardReversi() {
+		super(8, 8, 2);
+	}
+
+	@Override
+	public void init(Player[] players) {
+		super.init(players);
+        // Black (player 0)
+        setPlayerBitboard(0, (1L << (3 + 4 * 8)) | (1L << (4 + 3 * 8)));
+
+        // White (player 1)
+        setPlayerBitboard(1, (1L << (3 + 3 * 8)) | (1L << (4 + 4 * 8)));
+	}
+
+    public BitboardReversi(BitboardReversi other) {
+        super(other);
+    }
+
+	public long getLegalMoves() {
+		long legalMoves = 0L;
+
+		final long player = getPlayerBitboard(getCurrentPlayerIndex());
+		final long opponent = getPlayerBitboard(getNextPlayer());
+
+		final long empty = ~(player | opponent);
+
+		long mask;
+		long direction;
+
+		// north
+		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;
+
+		// 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 mask;
+		long direction;
+
+		// north
+		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;
+		}
+
+		// 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;
+	}
+
+    @Override
+    public BitboardReversi deepCopy() {return new BitboardReversi(this);}
+
+	public PlayResult play(long move) {
+		final long flips = getFlips(move);
+
+		long player = getPlayerBitboard(getCurrentPlayerIndex());
+		long opponent = getPlayerBitboard(getNextPlayer());
+
+		player |= move | flips;
+		opponent &= ~flips;
+
+		setPlayerBitboard(getCurrentPlayerIndex(), player);
+		setPlayerBitboard(getNextPlayer(), opponent);
+
+		nextTurn();
+
+		final long nextLegalMoves = getLegalMoves();
+
+		if (nextLegalMoves == 0) {
+			nextTurn();
+
+			final long skippedLegalMoves = getLegalMoves();
+
+			if (skippedLegalMoves == 0) {
+				int winner = getWinner();
+
+				if (winner == -1) {
+					state = new PlayResult(GameState.DRAW, -1);
+					return state;
+				}
+
+				state = new PlayResult(GameState.WIN, winner);
+				return state;
+			}
+
+			state = new PlayResult(GameState.TURN_SKIPPED, getCurrentPlayerIndex());
+			return state;
+		}
+
+		state = new PlayResult(GameState.NORMAL, getCurrentPlayerIndex());
+		return state;
+	}
+
+	public Score getScore() {
+		return new Score(
+			Long.bitCount(getPlayerBitboard(0)),
+			Long.bitCount(getPlayerBitboard(1))
+		);
+	}
+
+    public int getWinner(){
+        final long black = getPlayerBitboard(0);
+        final long white = getPlayerBitboard(1);
+
+        final int blackCount = Long.bitCount(black);
+        final int whiteCount = Long.bitCount(white);
+
+        if (blackCount == whiteCount){
+            return -1;
+        }
+        else if (blackCount > whiteCount){
+            return 0;
+        }
+        else{
+            return 1;
+        }
+    }
+}

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

@@ -1,11 +1,11 @@
-package org.toop.game.games.tictactoe;
+package org.toop.framework.game.games.tictactoe;
 
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.BitboardGame;
+import org.toop.framework.game.BitboardGame;
 
-public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
+public class BitboardTicTacToe extends BitboardGame {
 	private final long[] winningLines = {
 		0b111000000L, // top row
 		0b000111000L, // middle row
@@ -17,9 +17,15 @@ public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
 		0b001010100L  // anti-diagonal
 	};
 
-	public BitboardTicTacToe(Player<BitboardTicTacToe>[] players) {
-		super(3, 3, 2, players);
+	public BitboardTicTacToe() {
+		super(3, 3, 2);
 	}
+
+	@Override
+	public void init(Player[] players) {
+		super.init(players);
+	}
+
     public BitboardTicTacToe(BitboardTicTacToe other) {
         super(other);
     }
@@ -39,7 +45,8 @@ public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
 	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
@@ -50,7 +57,8 @@ public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
 
         // 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
@@ -59,11 +67,13 @@ public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
 
         // 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

@@ -0,0 +1,60 @@
+package org.toop.framework.game.players;
+
+import org.toop.framework.gameFramework.model.player.*;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+/**
+ * Represents a player controlled by an AI in a game.
+ * <p>
+ * This player uses an {@link AbstractAI} instance to determine its moves. The generic
+ * parameter {@code T} specifies the type of {@link GameR} the AI can handle.
+ * </p>
+ *
+ * @param <T> the specific type of game this AI player can play
+ */
+public class ArtificialPlayer extends AbstractPlayer {
+
+    /** The AI instance used to calculate moves. */
+    private final AI ai;
+
+    /**
+     * Constructs a new ArtificialPlayer using the specified AI.
+     *
+     * @param ai the AI instance that determines moves for this player
+     */
+    public ArtificialPlayer(AI ai, String name) {
+        super(name);
+        this.ai = ai;
+    }
+
+    public ArtificialPlayer(ArtificialPlayer other) {
+        super(other);
+        this.ai = other.ai.deepCopy();
+    }
+
+    /**
+     * Determines the next move for this player using its AI.
+     * <p>
+     * This method overrides {@link AbstractPlayer#getMove(GameR)}. Because the AI is
+     * typed to {@code T}, a runtime cast is required. It is the caller's
+     * responsibility to ensure that {@code gameCopy} is of type {@code T}.
+     * </p>
+     *
+     * @param gameCopy a copy of the current game state
+     * @return the integer representing the chosen move
+     * @throws ClassCastException if {@code gameCopy} is not of type {@code T}
+     */
+    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

@@ -1,4 +1,4 @@
-package org.toop.game.players;
+package org.toop.framework.game.players;
 
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractPlayer;
@@ -11,7 +11,7 @@ import java.util.concurrent.ExecutionException;
  *
  * @param <T> the type of turn-based game
  */
-public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+public class LocalPlayer extends AbstractPlayer {
 
     private CompletableFuture<Long> LastMove = new CompletableFuture<>();
 
@@ -29,7 +29,7 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
      *
      * @param other the player to copy
      */
-    public LocalPlayer(LocalPlayer<T> other) {
+    public LocalPlayer(LocalPlayer other) {
         super(other);
         this.LastMove = other.LastMove;
     }
@@ -41,15 +41,20 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
      * @return the chosen move
      */
     @Override
-    protected long determineMove(T gameCopy) {
+    protected long determineMove(TurnBasedGame gameCopy) {
         long legalMoves = gameCopy.getLegalMoves();
         long move;
 
-        do {
-            move = getLastMove();
-        } while ((legalMoves & move) == 0);
-
-        return move;
+        try {
+            do {
+                move = getLastMove();
+                IO.println("GETTING MOVE");
+            } while ((legalMoves & move) == 0);
+            return move;
+        } catch (Exception e) {
+            IO.println(e);
+        }
+        return -1;
     }
 
     /**
@@ -81,7 +86,23 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
      * @return a copy of this player
      */
     @Override
-    public LocalPlayer<T> deepCopy() {
-        return new LocalPlayer<>(this);
+    public LocalPlayer deepCopy() {
+        return new LocalPlayer(this);
     }
+
+    /*public void register() {
+        // Listening to PlayerAttemptedMove
+        new EventFlow().listen(GUIEvents.PlayerAttemptedMove.class, event -> {
+            if (!LastMove.isDone()) {
+                LastMove.complete(event.move()); // complete the future
+            }
+        }, true); // auto-unsubscribe
+    }
+
+    // This blocks until the next move arrives
+    public int take() throws ExecutionException, InterruptedException {
+        int move = LastMove.get(); // blocking
+        LastMove = new CompletableFuture<>(); // reset for next move
+        return move;
+    }*/
 }

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

@@ -1,4 +1,4 @@
-package org.toop.game.players;
+package org.toop.framework.game.players;
 
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.AbstractPlayer;
@@ -9,7 +9,7 @@ import org.toop.framework.gameFramework.model.player.Player;
  *
  * @param <T> the type of turn-based game
  */
-public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+public class OnlinePlayer extends AbstractPlayer {
 
     /**
      * Creates a new online player with the given name.
@@ -25,7 +25,7 @@ public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T>
      *
      * @param other the player to copy
      */
-    public OnlinePlayer(OnlinePlayer<T> other) {
+    public OnlinePlayer(OnlinePlayer other) {
         super(other);
     }
 
@@ -37,7 +37,7 @@ public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T>
      * @throws UnsupportedOperationException always
      */
     @Override
-    protected long determineMove(T gameCopy) {
+    protected long determineMove(TurnBasedGame gameCopy) {
         throw new UnsupportedOperationException("An online player does not support determining move");
     }
 
@@ -45,7 +45,7 @@ public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T>
      * {@inheritDoc}
      */
     @Override
-    public Player<T> deepCopy() {
-        return new OnlinePlayer<>(this);
+    public Player deepCopy() {
+        return new OnlinePlayer(this);
     }
 }

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

@@ -0,0 +1,41 @@
+package org.toop.framework.game.players;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AbstractPlayer;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.framework.networking.server.client.NettyClient;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class ServerPlayer extends AbstractPlayer {
+    private NettyClient client;
+    private CompletableFuture<Long> lastMove;
+
+    public ServerPlayer(NettyClient client) {
+        super(client.name());
+        this.client = client;
+    }
+
+    public void setMove(long move) {
+        lastMove.complete(move);
+    }
+
+    @Override
+    public Player deepCopy() {
+        return null;
+    }
+
+    @Override
+    public long determineMove(TurnBasedGame game) {
+        lastMove = new CompletableFuture<>();
+        System.out.println("Sending yourturn");
+        client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}\n");
+        try {
+            return lastMove.get();
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+}

framework/src/main/java/org/toop/framework/gameFramework/GameState.java

@@ -4,13 +4,13 @@ package org.toop.framework.gameFramework;
  * Represents the current state of a turn-based game.
  */
 public enum GameState {
-    /** Game is ongoing and no special condition applies. */
+    /** OnlineTurnBasedGame is ongoing and no special condition applies. */
     NORMAL,
 
-    /** Game ended in a draw. */
+    /** OnlineTurnBasedGame ended in a draw. */
     DRAW,
 
-    /** Game ended with a win for a player. */
+    /** OnlineTurnBasedGame ended with a win for a player. */
     WIN,
 
     /** Next player's turn was skipped. */

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

@@ -1,10 +1,8 @@
 package org.toop.framework.gameFramework.controller;
 
-import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
-import org.toop.framework.gameFramework.model.game.threadBehaviour.Controllable;
-import org.toop.framework.networking.events.NetworkEvents;
+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);
 
@@ -14,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<T extends TurnBasedGame<T>> {
-    Player<T> getPlayer(int index);
-}

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

@@ -1,7 +1,16 @@
 package org.toop.framework.gameFramework.model.game;
 
-public interface TurnBasedGame<T extends TurnBasedGame<T>> extends Playable, DeepCopyable<T>, PlayerProvider<T>, BoardProvider {
+import org.toop.framework.gameFramework.model.player.Player;
+
+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;
@@ -16,14 +15,14 @@ import java.util.function.Consumer;
  * a running flag, a game reference, and a logger.
  * Subclasses implement the actual game-loop logic.
  */
-public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implements ThreadBehaviour {
+public abstract class AbstractThreadBehaviour implements ThreadBehaviour {
     private LongPairConsumer onSendMove;
     private Runnable onUpdateUI;
     /** Indicates whether the game loop or event processing is active. */
     protected final AtomicBoolean isRunning = new AtomicBoolean();
 
     /** The game instance controlled by this behaviour. */
-    protected final T game;
+    protected final TurnBasedGame game;
 
     /** Logger for the subclass to report errors or debug info. */
     protected final Logger logger = LogManager.getLogger(this.getClass());
@@ -33,7 +32,7 @@ public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implem
      *
      * @param game the turn-based game to control
      */
-    public AbstractThreadBehaviour(T game) {
+    public AbstractThreadBehaviour(TurnBasedGame game) {
         this.game = game;
     }
 

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,6 +1,4 @@
-package org.toop.framework.gameFramework.model.game;
-
-import org.toop.framework.networking.events.NetworkEvents;
+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<T extends TurnBasedGame<T>> extends MoveProvider<T>, DeepCopyable<AI<T>> {
+public interface AI extends DeepCopyable<AI> {
+    long getMove(TurnBasedGame game);
 }

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

@@ -12,6 +12,6 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
  *
  * @param <T> the specific type of game this AI can play, extending {@link GameR}
  */
-public abstract class AbstractAI<T extends TurnBasedGame<T>> implements AI<T> {
+public abstract class AbstractAI implements AI {
     // Concrete AI implementations should override findBestMove(T game, int depth)
 }

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

@@ -5,44 +5,42 @@ import org.apache.logging.log4j.Logger;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 /**
- * Base class for players in a turn-based game.
- *
- * @param <T> the game type
+ * Abstract class representing a player in a game.
+ * <p>
+ * Players are entities that can make moves based on the current state of a game.
+ * player types, such as human players or AI players.
+ * </p>
+ * <p>
+ * Subclasses should override the {@link #getMove(GameR)} method to provide
+ * specific move logic.
+ * </p>
  */
-public abstract class AbstractPlayer<T extends TurnBasedGame<T>> implements Player<T> {
-
+public abstract class AbstractPlayer implements Player {
     private final Logger logger = LogManager.getLogger(this.getClass());
+
     private final String name;
 
-    /**
-     * Creates a new player with the given name.
-     *
-     * @param name the player name
-     */
     protected AbstractPlayer(String name) {
+        System.out.println("Player " + name + " has been created");
         this.name = name;
     }
 
-    /**
-     * Creates a copy of another player.
-     *
-     * @param other the player to copy
-     */
-    protected AbstractPlayer(AbstractPlayer<T> other) {
+    protected AbstractPlayer(AbstractPlayer other) {
         this.name = other.name;
     }
-
     /**
-     * Gets the player's move for the given game state.
-     * A deep copy is provided so the player cannot modify the real state.
+     * Determines the next move based on the provided game state.
      * <p>
-     * This method uses the Template Method Pattern: it defines the fixed
-     * algorithm and delegates the variable part to {@link #determineMove(T)}.
+     * The default implementation throws an {@link UnsupportedOperationException},
+     * indicating that concrete subclasses must override this method to provide
+     * actual move logic.
+     * </p>
      *
-     * @param game the current game
-     * @return the chosen move
+     * @param gameCopy a snapshot of the current game state
+     * @return an integer representing the chosen move
+     * @throws UnsupportedOperationException if the method is not overridden
      */
-    public final long getMove(T game) {
+    public final long getMove(TurnBasedGame game) {
         return determineMove(game.deepCopy());
     }
 
@@ -56,7 +54,7 @@ public abstract class AbstractPlayer<T extends TurnBasedGame<T>> implements Play
      * @param gameCopy a deep copy of the game
      * @return the chosen move
      */
-    protected abstract long determineMove(T gameCopy);
+    protected abstract long determineMove(TurnBasedGame gameCopy);
 
 
     /**

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<T extends TurnBasedGame<T>> {
-    long getMove(T 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

@@ -3,5 +3,7 @@ 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<T extends TurnBasedGame<T>> extends NameProvider, MoveProvider<T>, DeepCopyable<Player<T>> {
+public interface Player extends DeepCopyable<Player> {
+    String getName();
+    long getMove(TurnBasedGame game);
 }

framework/src/main/java/org/toop/framework/networking/connection/NetworkingClientEventListener.java

@@ -1,13 +1,13 @@
-package org.toop.framework.networking;
+package org.toop.framework.networking.connection;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.framework.SnowflakeGenerator;
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.eventbus.bus.EventBus;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.framework.networking.exceptions.ClientNotFoundException;
-import org.toop.framework.networking.interfaces.NetworkingClientManager;
+import org.toop.framework.networking.connection.events.NetworkEvents;
+import org.toop.framework.networking.connection.exceptions.ClientNotFoundException;
+import org.toop.framework.networking.connection.interfaces.NetworkingClientManager;
 
 public class NetworkingClientEventListener {
     private static final Logger logger = LogManager.getLogger(NetworkingClientEventListener.class);

framework/src/main/java/org/toop/framework/networking/connection/NetworkingClientManager.java

@@ -1,4 +1,4 @@
-package org.toop.framework.networking;
+package org.toop.framework.networking.connection;
 
 import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
@@ -10,13 +10,13 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.eventbus.bus.EventBus;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.framework.networking.exceptions.ClientNotFoundException;
-import org.toop.framework.networking.exceptions.CouldNotConnectException;
-import org.toop.framework.networking.interfaces.NetworkingClient;
-import org.toop.framework.networking.types.NetworkingConnector;
+import org.toop.framework.networking.connection.events.NetworkEvents;
+import org.toop.framework.networking.connection.exceptions.ClientNotFoundException;
+import org.toop.framework.networking.connection.exceptions.CouldNotConnectException;
+import org.toop.framework.networking.connection.interfaces.NetworkingClient;
+import org.toop.framework.networking.connection.types.NetworkingConnector;
 
-public class NetworkingClientManager implements org.toop.framework.networking.interfaces.NetworkingClientManager {
+public class NetworkingClientManager implements org.toop.framework.networking.connection.interfaces.NetworkingClientManager {
     private static final Logger logger = LogManager.getLogger(NetworkingClientManager.class);
 
     private final EventBus eventBus;

framework/src/main/java/org/toop/framework/networking/connection/clients/TournamentNetworkingClient.java

@@ -1,4 +1,4 @@
-package org.toop.framework.networking.clients;
+package org.toop.framework.networking.connection.clients;
 
 import io.netty.bootstrap.Bootstrap;
 import io.netty.channel.*;
@@ -12,9 +12,10 @@ import io.netty.util.CharsetUtil;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.framework.eventbus.bus.EventBus;
-import org.toop.framework.networking.exceptions.CouldNotConnectException;
-import org.toop.framework.networking.handlers.NetworkingGameClientHandler;
-import org.toop.framework.networking.interfaces.NetworkingClient;
+import org.toop.framework.networking.connection.events.NetworkEvents;
+import org.toop.framework.networking.connection.exceptions.CouldNotConnectException;
+import org.toop.framework.networking.connection.handlers.NetworkingGameClientHandler;
+import org.toop.framework.networking.connection.interfaces.NetworkingClient;
 
 import java.net.InetSocketAddress;
 
@@ -23,6 +24,7 @@ public class TournamentNetworkingClient implements NetworkingClient {
 
     private final EventBus eventBus;
     private Channel channel;
+    private long clientId;
 
     public TournamentNetworkingClient(EventBus eventBus) {
         this.eventBus = eventBus;
@@ -35,6 +37,7 @@ public class TournamentNetworkingClient implements NetworkingClient {
 
     @Override
     public void connect(long clientId, String host, int port) throws CouldNotConnectException {
+        this.clientId = clientId;
         try {
             Bootstrap bootstrap = new Bootstrap();
             EventLoopGroup workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
@@ -75,6 +78,7 @@ public class TournamentNetworkingClient implements NetworkingClient {
             logger.info("Connection {} sent message: '{}' ", this.channel.remoteAddress(), literalMsg);
         } else {
             logger.warn("Cannot send message: '{}', connection inactive. ", literalMsg);
+            eventBus.post(new NetworkEvents.ClosedConnection(clientId));
         }
     }
 

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

@@ -1,4 +1,4 @@
-package org.toop.framework.networking.events;
+package org.toop.framework.networking.connection.events;
 
 import java.util.*;
 import java.util.concurrent.CompletableFuture;
@@ -6,8 +6,8 @@ import java.util.concurrent.CompletableFuture;
 import org.toop.annotations.AutoResponseResult;
 import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.eventbus.events.*;
-import org.toop.framework.networking.interfaces.NetworkingClient;
-import org.toop.framework.networking.types.NetworkingConnector;
+import org.toop.framework.networking.connection.interfaces.NetworkingClient;
+import org.toop.framework.networking.connection.types.NetworkingConnector;
 
 /**
  * Defines all event types related to the networking subsystem.
@@ -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, 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 {}
@@ -102,7 +105,7 @@ public class NetworkEvents extends EventsBase {
             implements GenericEvent {}
 
     /** Requests to accept an existing challenge. */
-    public record SendAcceptChallenge(long clientId, int challengeId)
+    public record SendAcceptChallenge(long clientId, long challengeId)
             implements GenericEvent {}
 
     /** Requests to forfeit the current game. */
@@ -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/exceptions/ClientNotFoundException.java

@@ -1,4 +1,4 @@
-package org.toop.framework.networking.exceptions;
+package org.toop.framework.networking.connection.exceptions;
 
 /**
  * Thrown when an operation is attempted on a networking client

framework/src/main/java/org/toop/framework/networking/connection/exceptions/CouldNotConnectException.java

@@ -1,4 +1,4 @@
-package org.toop.framework.networking.exceptions;
+package org.toop.framework.networking.connection.exceptions;
 
 public class CouldNotConnectException extends RuntimeException {
 

framework/src/main/java/org/toop/framework/networking/connection/exceptions/NetworkingInitializationException.java

@@ -1,4 +1,4 @@
-package org.toop.framework.networking.exceptions;
+package org.toop.framework.networking.connection.exceptions;
 
 public class NetworkingInitializationException extends RuntimeException {
     public NetworkingInitializationException(String message, Throwable cause) {

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

@@ -1,15 +1,16 @@
-package org.toop.framework.networking.handlers;
+package org.toop.framework.networking.connection.handlers;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
 
+import java.util.Arrays;
 import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.framework.eventbus.bus.EventBus;
-import org.toop.framework.networking.events.NetworkEvents;
+import org.toop.framework.networking.connection.events.NetworkEvents;
 
 public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
     private static final Logger logger = LogManager.getLogger(NetworkingGameClientHandler.class);
@@ -94,6 +95,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                     case "HELP":
                         helpHandler(recSrvRemoved);
                         return;
+                    case "RESULTS":
+                        resultsHandler(recSrvRemoved);
+                        return;
                     default:
                         // return
                 }
@@ -103,6 +107,34 @@ 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) {
+        IO.println(rec);
+
+        String gameTypeRaw = extract(rec, "GAMETYPE");
+        String usersRaw    = extract(rec, "USERS");
+        String scoresRaw   = extract(rec, "SCORES");
+
+        String[] users = Arrays.stream(usersRaw.substring(1, usersRaw.length() - 1).split(","))
+                .map(s -> s.trim().replace("\"", ""))
+                .toArray(String[]::new);
+
+        Integer[] scores = Arrays.stream(scoresRaw.substring(1, scoresRaw.length() - 1).split(","))
+                .map(String::trim)
+                .map(Integer::parseInt)
+                .toArray(Integer[]::new);
+
+        eventBus.post(new NetworkEvents.TournamentResultResponse(this.connectionId, gameTypeRaw, users, scores));
+    }
+
     private void gameMoveHandler(String rec) {
         String[] msg =
                 Pattern.compile(

framework/src/main/java/org/toop/framework/networking/connection/interfaces/NetworkingClient.java

@@ -1,6 +1,6 @@
-package org.toop.framework.networking.interfaces;
+package org.toop.framework.networking.connection.interfaces;
 
-import org.toop.framework.networking.exceptions.CouldNotConnectException;
+import org.toop.framework.networking.connection.exceptions.CouldNotConnectException;
 
 import java.net.InetSocketAddress;
 

framework/src/main/java/org/toop/framework/networking/connection/interfaces/NetworkingClientManager.java

@@ -1,8 +1,8 @@
-package org.toop.framework.networking.interfaces;
+package org.toop.framework.networking.connection.interfaces;
 
-import org.toop.framework.networking.exceptions.ClientNotFoundException;
-import org.toop.framework.networking.exceptions.CouldNotConnectException;
-import org.toop.framework.networking.types.NetworkingConnector;
+import org.toop.framework.networking.connection.exceptions.ClientNotFoundException;
+import org.toop.framework.networking.connection.exceptions.CouldNotConnectException;
+import org.toop.framework.networking.connection.types.NetworkingConnector;
 
 public interface NetworkingClientManager {
     void startClient(

framework/src/main/java/org/toop/framework/networking/connection/types/NetworkingConnector.java

@@ -1,4 +1,4 @@
-package org.toop.framework.networking.types;
+package org.toop.framework.networking.connection.types;
 
 import java.util.concurrent.TimeUnit;
 

framework/src/main/java/org/toop/framework/networking/connection/types/ServerCommand.java

@@ -1,3 +1,3 @@
-package org.toop.framework.networking.types;
+package org.toop.framework.networking.connection.types;
 
 public record ServerCommand(long clientId, String command) {}

framework/src/main/java/org/toop/framework/networking/connection/types/ServerMessage.java

@@ -0,0 +1,3 @@
+package org.toop.framework.networking.connection.types;
+
+public record ServerMessage(String message) {}

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

@@ -0,0 +1,25 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+
+public interface GameServer<GAMETYPE, CLIENT, CHALLENGEIDTYPE> {
+    OnlineGame<TurnBasedGame> startGame(String gameType, CompletableFuture<Void> futureOrNull, CLIENT... clients);
+
+    void addClient(CLIENT client);
+    void removeClient(CLIENT client);
+
+    void challengeClient(String fromClientName, String toClientName, String gameTypeKey);
+    void acceptChallenge(CHALLENGEIDTYPE challengeId);
+
+    void subscribeClient(String clientName, String gameTypeKey);
+    void unsubscribeClient(String clientName);
+
+    List<String> gameTypes();
+    List<OnlineGame<GAMETYPE>> ongoingGames();
+
+    List<CLIENT> onlineUsers();
+    void shutdown();
+}

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

@@ -0,0 +1,10 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.networking.server.client.NettyClient;
+
+public interface OnlineGame<T> {
+    long id();
+    T game();
+    NettyClient[] users();
+    void start();
+}

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

@@ -0,0 +1,86 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.game.gameThreads.ServerThreadBehaviour;
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.networking.server.client.NettyClient;
+
+import java.util.concurrent.CompletableFuture;
+
+public class OnlineTurnBasedGame implements OnlineGame<TurnBasedGame> {
+
+    private long id;
+    private NettyClient[] clients;
+    private TurnBasedGame game;
+    private ServerThreadBehaviour gameThread;
+
+    private CompletableFuture<Void> futureOrNull = null;
+
+    public OnlineTurnBasedGame(TurnBasedGame game, CompletableFuture<Void> futureOrNull, NettyClient... clients) {
+        this.game = game;
+        this.gameThread = new ServerThreadBehaviour(
+                game,
+                (pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()),
+                (pair) -> notifyGameEnd(pair.getLeft(), pair.getRight())
+        );
+        this.futureOrNull = futureOrNull;
+        this.clients = clients;
+    }
+
+    public OnlineTurnBasedGame(TurnBasedGame game, NettyClient... clients) {
+        this.game = game;
+        this.gameThread = new ServerThreadBehaviour(
+                game,
+                (pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()),
+                (pair) -> notifyGameEnd(pair.getLeft(), pair.getRight())
+        );
+        this.clients = clients;
+    }
+
+    private void notifyMoveMade(String speler, int move){
+        for (NettyClient client : clients) {
+            client.send(String.format("SVR GAME MOVE {PLAYER: \"%s\", MOVE: \"%s\", DETAILS: \"<reactie spel op zet>\"}\n", speler, move));
+        }
+    }
+
+    private void notifyGameEnd(GameState state, int winner){
+        if (state == GameState.DRAW){
+            for (NettyClient client : clients) {
+                client.send(String.format("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"<score speler2>\", COMMENT: \"<comment>\"}\n"));
+            }
+        }
+        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"));
+        }
+
+        // Remove game fromt clients
+        for(NettyClient client : clients) {
+            client.clearGame();
+        }
+
+        if (futureOrNull != null) {
+            futureOrNull.complete(null);
+        }
+    }
+
+    @Override
+    public long id() {
+        return id;
+    }
+
+    @Override
+    public org.toop.framework.gameFramework.model.game.TurnBasedGame game() {
+        return game;
+    }
+
+    @Override
+    public NettyClient[] users() {
+        return clients;
+    }
+
+    @Override
+    public void start(){
+        this.gameThread.start();
+    }
+}

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

@@ -0,0 +1,311 @@
+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;
+import org.toop.framework.networking.server.challenges.gamechallenge.GameChallengeTimer;
+import org.toop.framework.networking.server.client.NettyClient;
+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.utils.ImmutablePair;
+
+import java.util.*;
+import java.util.concurrent.*;
+import java.time.Duration;
+
+public class Server implements GameServer<TurnBasedGame, NettyClient, Long> {
+
+    final private TurnBasedGameTypeStore gameTypesStore;
+    final private ClientStore<Long, NettyClient> clientStore;
+    final private List<GameChallenge> gameChallenges = new CopyOnWriteArrayList<>();
+    final private TurnBasedGameStore gameStore;
+
+    final private SubscriptionStore subscriptionStore;
+
+    final private Duration challengeDuration;
+    final private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+
+    public Server(
+            Duration challengeDuration,
+            TurnBasedGameTypeStore turnBasedGameTypeStore,
+            ClientStore<Long, NettyClient> clientStore,
+            TurnBasedGameStore gameStore,
+            SubscriptionStore subStore
+    ) {
+        this.gameTypesStore = turnBasedGameTypeStore;
+        this.challengeDuration = challengeDuration;
+        this.clientStore = clientStore;
+        this.gameStore = gameStore;
+        this.subscriptionStore = subStore;
+
+        scheduler.schedule(this::serverTask, 0, TimeUnit.MILLISECONDS);
+    }
+
+    @Override
+    public void addClient(NettyClient client) {
+        clientStore.add(client);
+    }
+
+    @Override
+    public void removeClient(NettyClient client) {
+        clientStore.remove(client.id());
+    }
+
+    @Override
+    public List<String> gameTypes() {
+        return new ArrayList<>(gameTypesStore.all().keySet());
+    }
+
+    @Override
+    public List<OnlineGame<TurnBasedGame>> ongoingGames() {
+        return gameStore.all().stream().toList();
+    }
+
+    @Override
+    public void challengeClient(String fromUser, String toUser, String gameType) {
+
+        NettyClient from = getUser(fromUser);
+        if (from == null) {
+            return;
+        }
+
+        if (!gameTypesStore.all().containsKey(gameType)) {
+            from.send("ERR gametype not found \n");
+            return;
+        }
+
+        NettyClient to = getUser(toUser);
+        if (to == null) {
+            from.send("ERR user not found \n");
+            return;
+        }
+
+        var ch = new GameChallenge(from, to, gameType, new GameChallengeTimer(challengeDuration));
+
+        to.send(
+                "SVR GAME CHALLENGE {CHALLENGER: \"%s\", CHALLENGENUMBER: \"%s\", GAMETYPE: \"%s\"} \n"
+                        .formatted(from.name(), ch.id(), gameType)
+        );
+
+        if (!isValidChallenge(ch)) {
+            warnUserExpiredChallenge(from, ch.id());
+            ch.forceExpire();
+            return;
+        }
+
+        gameChallenges.addLast(ch);
+    }
+
+    @Override
+    public void acceptChallenge(Long challengeId) {
+        for (var challenge : gameChallenges) {
+            if (challenge.id() == challengeId) {
+                startGame(challenge.acceptChallenge(), null, challenge.getUsers());
+                break;
+            }
+        }
+    }
+
+    @Override
+    public void subscribeClient(String clientName, String gameTypeKey) {
+
+        if (!gameTypesStore.all().containsKey(gameTypeKey)) {
+            return;
+        }
+
+        subscriptionStore.add(new ImmutablePair<>(gameTypeKey, clientName));
+    }
+
+    @Override
+    public void unsubscribeClient(String clientName) {
+        subscriptionStore.remove(clientName);
+    }
+
+    @Override
+    public OnlineGame<TurnBasedGame> startGame(String gameType, CompletableFuture<Void> futureOrNull, NettyClient... clients) {
+        if (!gameTypesStore.all().containsKey(gameType)) return null;
+
+        try {
+            ServerPlayer[] players = new ServerPlayer[clients.length];
+            var game = new OnlineTurnBasedGame(gameTypesStore.create(gameType), futureOrNull, clients);
+
+            for (int i = 0; i < clients.length; i++) {
+                players[i] = new ServerPlayer(clients[i]);
+                clients[i].setGame(new ImmutablePair<>(game, players[i]));
+            }
+
+            game.game().init(players);
+            gameStore.add(game);
+
+            clients[0].send(String.format("SVR GAME MATCH {PLAYERTOMOVE: \"%s\", GAMETYPE: \"%s\", OPPONENT: \"%s\"}\n",
+                    clients[0].name(),
+                    gameType,
+                    clients[1].name()));
+            clients[1].send(String.format("SVR GAME MATCH {PLAYERTOMOVE: \"%s\", GAMETYPE: \"%s\", OPPONENT: \"%s\"}\n",
+                    clients[0].name(),
+                    gameType,
+                    clients[0].name()));
+            game.start();
+            return game;
+        } catch (Exception e) {
+            IO.println("ERROR: Failed to start OnlineTurnBasedGame");
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override
+    public List<NettyClient> onlineUsers() {
+        return clientStore.all().stream().toList();
+    }
+
+    @Override
+    public void shutdown() {
+        scheduler.shutdown();
+        gameChallenges.clear();
+    }
+
+    private void serverTask() {
+        checkChallenges();
+        checkSubscriptions();
+        scheduler.schedule(this::serverTask, 500, TimeUnit.MILLISECONDS);
+    }
+
+    private void checkChallenges() {
+        for (int i = gameChallenges.size() - 1; i >= 0; i--) {
+            var challenge = gameChallenges.get(i);
+
+            if (isValidChallenge(challenge)) continue;
+
+            if (challenge.isExpired()) {
+                if (!challenge.isChallengeAccepted()) Arrays.stream(challenge.getUsers())
+                        .forEach(user -> warnUserExpiredChallenge(user, challenge.id()));
+
+                gameChallenges.remove(i);
+            }
+        }
+    }
+
+    private void checkSubscriptions() {
+        if (subscriptionStore.allKeys().isEmpty()) return;
+
+        Random ran = new Random();
+
+        for (String key : subscriptionStore.allKeys()) {
+            List<String> userNames = (List<String>) subscriptionStore.allValues(key);
+            if (userNames.size() < 2) continue;
+
+            while (userNames.size() > 1) {
+                int left = ran.nextInt(userNames.size());
+                int right;
+                do {
+                    right = ran.nextInt(userNames.size());
+                } while (left == right);
+
+                String userLeft = userNames.get(left);
+                String userRight = userNames.get(right);
+
+                // Remove user if he is in a game
+                boolean userInGame = false;
+
+                if (getUser(userLeft).game() != null) {
+                    userNames.remove(userLeft);
+                    userInGame = true;
+                } else if (getUser(userRight).game() != null) {
+                    userNames.remove(userRight);
+                    userInGame = true;
+                }
+
+                if  (userInGame) { continue; }
+
+                int first = Math.max(left, right);
+                int second = Math.min(left, right);
+
+                userNames.remove(first);
+                userNames.remove(second);
+
+                startGame(key, null, getUser(userLeft), getUser(userRight));
+            }
+        }
+    }
+
+    private NettyClient getUser(String username) {
+        return clientStore.all().stream().filter(e -> e.name().equalsIgnoreCase(username)).findFirst().orElse(null);
+    }
+
+    private NettyClient getUser(long id) {
+        return clientStore.get(id);
+    }
+
+    private void warnUserExpiredChallenge(NettyClient client, long challengeId) {
+        client.send("SVR GAME CHALLENGE CANCELLED {CHALLENGENUMBER: \"" + challengeId + "\"}" + "\n");
+    }
+
+    private boolean isValidChallenge(GameChallenge gameChallenge) { // TODO move to challenge class
+        for (var user : gameChallenge.getUsers()) {
+            if (clientStore.get(user.id()) == null) {
+                return false;
+            }
+
+            if (user.game() != null) {
+                return false;
+            }
+
+            if (gameChallenge.isExpired()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public void startTournament(Tournament tournament, String gameType) {
+        try {
+            var tb = new TournamentBuilder();
+            var cTournament = tb.create(
+                    tournament,
+                    onlineUsers(),
+                    this,
+                    new BasicScoreManager(new HashMap<>()),
+                    new BasicMatchManager(),
+                    new RandomShuffle()
+            );
+            new Thread(() -> cTournament.run(gameType)).start();
+        } catch (IllegalArgumentException e) {
+            getUser("host").send("ERR not enough clients to start a tournament");
+        } catch (RuntimeException e) {
+            getUser("host").send("ERR no matches could be created to start a tournament with");
+        }
+    }
+
+    public void endTournament(Map<NettyClient, Integer> score, String gameType) {
+
+        List<String> u = new ArrayList<>();
+        List<Integer> s = new ArrayList<>();
+
+        for (var entry : score.entrySet()) {
+            u.add(entry.getKey().name());
+            s.add(entry.getValue());
+        }
+
+        Gson gson = new Gson();
+
+        String users = gson.toJson(u);
+        String scores = gson.toJson(s);
+
+        String msg = String.format(
+                "SVR RESULTS {GAMETYPE: \"%s\", USERS: %s, SCORES: %s, TOURNAMENT: 1}",
+                gameType,
+                users,
+                scores
+        );
+
+        for (var user : onlineUsers()) {
+            user.send(msg);
+        }
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/challenges/gamechallenge/GameChallenge.java

@@ -0,0 +1,49 @@
+package org.toop.framework.networking.server.challenges.gamechallenge;
+
+import org.toop.framework.SnowflakeGenerator;
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.utils.SimpleTimer;
+
+public class GameChallenge {
+    private final long id = SnowflakeGenerator.nextId(); // I don't need this, but the tournament server uses it...
+
+    private final NettyClient from;
+    private final NettyClient to;
+    private final String gameType;
+    private final SimpleTimer timer;
+
+    private boolean isChallengeAccepted = false;
+
+    public GameChallenge(NettyClient from, NettyClient to, String gameType, SimpleTimer timer) {
+        this.from = from;
+        this.to = to;
+        this.gameType = gameType;
+        this.timer = timer;
+    }
+
+    public long id() {
+        return id;
+    }
+
+    public NettyClient[] getUsers() {
+        return new NettyClient[]{from, to};
+    }
+
+    public void forceExpire() {
+        timer.forceExpire();
+    }
+
+    public String acceptChallenge() {
+        isChallengeAccepted = true;
+        timer.forceExpire();
+        return gameType;
+    }
+
+    public boolean isChallengeAccepted() {
+        return isChallengeAccepted;
+    }
+
+    public boolean isExpired() {
+        return timer.isExpired();
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/challenges/gamechallenge/GameChallengeTimer.java

@@ -0,0 +1,35 @@
+package org.toop.framework.networking.server.challenges.gamechallenge;
+
+import org.toop.framework.utils.SimpleTimer;
+
+import java.time.Instant;
+import java.time.Duration;
+
+public class GameChallengeTimer implements SimpleTimer {
+
+    private final Instant createdAt;
+    private final Duration timeout;
+
+    private boolean isExpired = false;
+
+    public GameChallengeTimer(Duration duration) {
+        this.createdAt = Instant.now();
+        this.timeout = duration;
+    }
+
+    @Override
+    public void forceExpire() {
+        this.isExpired = true;
+    }
+
+    @Override
+    public boolean isExpired() {
+        if (this.isExpired) return true;
+        return Instant.now().isAfter(createdAt.plus(timeout));
+    }
+
+    @Override
+    public long secondsRemaining() {
+        return Duration.between(Instant.now(), createdAt.plus(timeout)).toSeconds();
+    }
+}

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

@@ -0,0 +1,19 @@
+package org.toop.framework.networking.server.client;
+
+import org.toop.framework.networking.server.OnlineTurnBasedGame;
+import org.toop.framework.utils.Pair;
+
+public interface Client<G, P> {
+    long id();
+
+    String name();
+    void setName(String name);
+
+    OnlineTurnBasedGame game();
+    P player();
+
+    void setGame(Pair<G, P> gamePair);
+    void clearGame();
+
+    void send(String message);
+}

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

@@ -0,0 +1,66 @@
+package org.toop.framework.networking.server.client;
+
+import io.netty.channel.ChannelHandlerContext;
+import org.toop.framework.game.players.ServerPlayer;
+import org.toop.framework.networking.server.OnlineTurnBasedGame;
+import org.toop.framework.utils.Pair;
+
+public class NettyClient implements Client<OnlineTurnBasedGame, ServerPlayer> {
+    final private long id;
+    private ChannelHandlerContext ctx;
+    private String name;
+    private Pair<OnlineTurnBasedGame, ServerPlayer> gamePair;
+
+    public NettyClient(long userId, String name) {
+        this.id = userId;
+        this.name = name;
+    }
+
+    @Override
+    public long id() {
+        return id;
+    }
+
+    @Override
+    public String name() {
+        return name;
+    }
+
+    @Override
+    public void setGame(Pair<OnlineTurnBasedGame, ServerPlayer> gamePair) {
+        this.gamePair = gamePair;
+    }
+
+    @Override
+    public void clearGame() {
+        this.gamePair = null;
+    }
+
+    @Override
+    public OnlineTurnBasedGame game() {
+        if (this.gamePair == null) {
+            return null;
+        }
+        return this.gamePair.getLeft();
+    }
+
+    @Override
+    public ServerPlayer player() {
+        return this.gamePair.getRight();
+    }
+
+    @Override
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public void send(String message) {
+        IO.println(message);
+        ctx.channel().writeAndFlush(message + "\r\n");
+    }
+
+    public void setCtx(ChannelHandlerContext ctx) {
+        this.ctx = ctx;
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/connectionHandler/ClientSession.java

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server.connectionHandler;
+
+import org.toop.framework.networking.server.client.Client;
+
+public interface ClientSession<G, P> {
+    Client<G, P> client();
+}

framework/src/main/java/org/toop/framework/networking/server/connectionHandler/NettyClientSession.java

@@ -0,0 +1,58 @@
+package org.toop.framework.networking.server.connectionHandler;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import org.toop.framework.game.players.ServerPlayer;
+import org.toop.framework.networking.server.OnlineTurnBasedGame;
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.handlers.Handler;
+import org.toop.framework.networking.server.parsing.ParsedMessage;
+import org.toop.framework.networking.server.Server;
+import org.toop.framework.networking.server.client.Client;
+import org.toop.framework.networking.server.parsing.Parser;
+
+public class NettyClientSession extends SimpleChannelInboundHandler<String> implements ClientSession<OnlineTurnBasedGame, ServerPlayer> {
+
+    private final NettyClient client;
+    private final Server server;
+    private final Handler<ParsedMessage> handler;
+
+    public NettyClientSession(NettyClient client, Server server, Handler<ParsedMessage> handler) {
+        this.client = client;
+        this.server = server;
+        this.handler = handler;
+    }
+
+    @Override
+    public Client<OnlineTurnBasedGame, ServerPlayer> client() {
+        return client;
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) {
+        ctx.writeAndFlush("Welcome " + client.id() + " please login" + "\n");
+
+        client.setCtx(ctx);
+        server.addClient(client); // TODO set correct name on login
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
+
+        ParsedMessage p = Parser.parse(msg);
+        if (p == null) return;
+
+        handler.handle(p);
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        cause.printStackTrace();
+        ctx.close();
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) {
+        server.removeClient(client);
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/gateway/GatewayServer.java

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server.gateway;
+
+public interface GatewayServer {
+    void start() throws Exception;
+    void stop();
+    int port();
+}

framework/src/main/java/org/toop/framework/networking/server/gateway/NettyGatewayServer.java

@@ -0,0 +1,111 @@
+package org.toop.framework.networking.server.gateway;
+
+import io.netty.bootstrap.ServerBootstrap;
+import io.netty.channel.*;
+import io.netty.channel.nio.NioEventLoopGroup;
+import io.netty.channel.nio.NioIoHandler;
+import io.netty.channel.socket.nio.NioServerSocketChannel;
+import io.netty.channel.socket.nio.NioSocketChannel;
+import io.netty.handler.codec.LineBasedFrameDecoder;
+import io.netty.handler.codec.string.StringDecoder;
+import io.netty.handler.codec.string.StringEncoder;
+import io.netty.handler.logging.LogLevel;
+import io.netty.handler.logging.LoggingHandler;
+import org.toop.framework.SnowflakeGenerator;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.networking.server.client.NettyClient;
+import org.toop.framework.networking.server.connectionHandler.NettyClientSession;
+import org.toop.framework.networking.server.Server;
+import org.toop.framework.networking.server.handlers.MessageHandler;
+import org.toop.framework.networking.server.stores.MapSubscriptionStore;
+import org.toop.framework.networking.server.stores.NettyClientStore;
+import org.toop.framework.networking.server.stores.TurnBasedGameStore;
+import org.toop.framework.networking.server.stores.TurnBasedGameTypeStore;
+
+import java.time.Duration;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CopyOnWriteArrayList;
+
+public class NettyGatewayServer implements GatewayServer {
+    private final int port;
+    private final Server gs;
+
+    ChannelFuture future;
+    EventLoopGroup bossGroup;
+    EventLoopGroup workerGroup;
+
+    public NettyGatewayServer(
+            int port,
+            TurnBasedGameTypeStore turnBasedGameTypeStore,
+            Duration challengeDuration
+    ) {
+        this.port = port;
+        this.gs = new Server(
+                challengeDuration,
+                turnBasedGameTypeStore,
+                new NettyClientStore(new ConcurrentHashMap<>()),
+                new TurnBasedGameStore(new CopyOnWriteArrayList<>()),
+                new MapSubscriptionStore(new ConcurrentHashMap<>())
+        );
+    }
+
+    @Override
+    public void start() throws InterruptedException {
+
+        bossGroup = new NioEventLoopGroup(1);
+        workerGroup = new MultiThreadIoEventLoopGroup(NioIoHandler.newFactory());
+
+        try {
+            ServerBootstrap bootstrap = new ServerBootstrap();
+            bootstrap.group(workerGroup);
+            bootstrap.channel(NioServerSocketChannel.class);
+            bootstrap.option(ChannelOption.SO_BACKLOG, 128);
+            bootstrap.childOption(ChannelOption.SO_KEEPALIVE, true);
+            bootstrap.handler(new LoggingHandler(LogLevel.INFO));
+            bootstrap.childHandler(
+                    new ChannelInitializer<NioSocketChannel>() {
+                        @Override
+                        protected void initChannel(NioSocketChannel ch) {
+
+                            ChannelPipeline pipeline = ch.pipeline();
+
+                            pipeline.addLast(new LineBasedFrameDecoder(8192));
+                            pipeline.addLast(new StringDecoder());
+                            pipeline.addLast(new StringEncoder());
+
+                            long userid = SnowflakeGenerator.nextId();
+                            NettyClient client = new NettyClient(userid, ""+userid);
+                            pipeline.addLast(new NettyClientSession(client, gs, new MessageHandler(gs, client)));
+                        }
+                    }
+            );
+
+            future = bootstrap.bind(port).sync();
+
+            future.channel().closeFuture().sync();
+        } finally {
+            bossGroup.shutdownGracefully();
+            workerGroup.shutdownGracefully();
+        }
+    }
+
+    @Override
+    public void stop() {
+        if (future == null) {
+            return;
+        }
+
+        future.channel().close();
+        bossGroup.shutdownGracefully();
+        workerGroup.shutdownGracefully();
+
+        future = null;
+        bossGroup = null;
+        workerGroup = null;
+    }
+
+    @Override
+    public int port() {
+        return port;
+    }
+}

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

@@ -0,0 +1,5 @@
+package org.toop.framework.networking.server.handlers;
+
+public interface Handler<T> {
+    void handle(T message);
+}

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

@@ -0,0 +1,122 @@
+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.parsing.ParsedMessage;
+import org.toop.framework.networking.server.tournaments.BasicTournament;
+import org.toop.framework.utils.Utils;
+
+public class MessageHandler implements Handler<ParsedMessage> {
+
+    private final Server server;
+    private final Client<OnlineTurnBasedGame, ServerPlayer> client;
+
+    public MessageHandler(Server server, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        this.server = server;
+        this.client = client;
+    }
+
+    @Override
+    public void handle(ParsedMessage message) {
+        switch (message.command()) {
+            case "ping" -> client.send("PONG");
+            case "login" -> handleLogin(message, client);
+            case "get" -> handleGet(message, client);
+            case "subscribe" -> handleSubscribe(message, client);
+            case "move" -> handleMove(message, client);
+            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");
+        }
+    }
+
+    // DO NOT INVERT
+    private boolean hasArgs(String... args) {
+        if (args.length < 1) {
+            client.send("ERR not enough arguments");
+            return false;
+        }
+        return true;
+    }
+
+    private void handleLogin(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        if (!hasArgs(p.args())) return;
+
+        client.setName(p.args()[0]);
+    }
+
+    private void handleSubscribe(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        if (!hasArgs(p.args())) return;
+
+        server.subscribeClient(client.name(), p.args()[0]);
+    }
+
+    private void handleHelp(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        // TODO
+    }
+
+    private void handleMessage(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        // TODO
+    }
+
+    private void handleGet(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        if (!hasArgs(p.args())) return;
+
+        switch (p.args()[0]) {
+            case "playerlist" -> {
+                var names = server.onlineUsers().stream().map(Client::name).iterator();
+                client.send("SVR PLAYERLIST " + Utils.returnQuotedString(names));
+            }
+            case "gamelist" -> {
+                var names = server.gameTypes().stream().iterator();
+                client.send("SVR GAMELIST " + Utils.returnQuotedString(names));
+            }
+        }
+    }
+
+    private void handleChallenge(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        if (!hasArgs(p.args())) return;
+        if (p.args().length < 2) return;
+
+        if (p.args()[0].equalsIgnoreCase("accept")) {
+            try {
+                long id = Long.parseLong(p.args()[1]);
+
+                if (id <= 0) {
+                    client.send("ERR id must be a positive number");
+                    return;
+                }
+
+                server.acceptChallenge(id);
+
+            } catch (NumberFormatException e) {
+                client.send("ERR id is not a valid number or too big");
+                return;
+            }
+            return;
+        }
+
+        server.challengeClient(client.name(), p.args()[0], p.args()[1]);
+    }
+
+    private void handleMove(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        if(!hasArgs(p.args())) return;
+
+        // TODO check if not number
+        client.player().setMove(1L << Integer.parseInt(p.args()[0]));
+    }
+
+    private void handleTournament(ParsedMessage p, Client<OnlineTurnBasedGame, ServerPlayer> client) {
+        if(!hasArgs(p.args())) return;
+
+        if (!client.name().equalsIgnoreCase("host")) return;
+
+        if (p.args()[0].equalsIgnoreCase("start") && p.args().length > 1) {
+            server.startTournament(new BasicTournament(), p.args()[1]);
+        }
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/parsing/ParsedMessage.java

@@ -0,0 +1,4 @@
+package org.toop.framework.networking.server.parsing;
+
+public record ParsedMessage(String command, String... args) {}
+

framework/src/main/java/org/toop/framework/networking/server/parsing/Parser.java

@@ -0,0 +1,24 @@
+package org.toop.framework.networking.server.parsing;
+
+import java.util.LinkedList;
+import java.util.List;
+
+public class Parser {
+    public static ParsedMessage parse(String msg) {
+        // TODO, what if empty string.
+
+        if (msg.isEmpty()) return null;
+
+        msg = msg.trim().toLowerCase();
+
+        List<String> parts = new LinkedList<>(List.of(msg.split(" ")));
+
+        if (parts.size() > 1) {
+            String command = parts.removeFirst();
+            return new ParsedMessage(command, parts.toArray(String[]::new));
+        }
+        else {
+            return new ParsedMessage(msg);
+        }
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/stores/ClientStore.java

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server.stores;
+
+import org.toop.framework.game.players.ServerPlayer;
+import org.toop.framework.networking.server.OnlineTurnBasedGame;
+import org.toop.framework.networking.server.client.Client;
+
+public interface ClientStore<ID, T extends Client<OnlineTurnBasedGame, ServerPlayer>> extends Store<ID, T> {}

framework/src/main/java/org/toop/framework/networking/server/stores/GameStore.java

@@ -0,0 +1,3 @@
+package org.toop.framework.networking.server.stores;
+
+public interface GameStore<T, K> extends Store<T, K> {}

framework/src/main/java/org/toop/framework/networking/server/stores/MapSubscriptionStore.java

@@ -0,0 +1,71 @@
+package org.toop.framework.networking.server.stores;
+
+import org.toop.framework.utils.ImmutablePair;
+
+import java.util.*;
+
+public class MapSubscriptionStore implements SubscriptionStore {
+
+    final private Map<String, List<String>> subscriptions;
+
+    public MapSubscriptionStore(Map<String, List<String>> initMap) {
+        this.subscriptions = initMap;
+    }
+
+    @Override
+    public void add(ImmutablePair<String, String> adding) {
+        subscriptions.forEach((_, clientNames) -> clientNames.remove(adding.getRight()));
+        subscriptions.computeIfAbsent(
+                        adding.getLeft(),
+                        _ -> new ArrayList<>())
+                .add(adding.getRight());
+    }
+
+    @Override
+    public void remove(String remover) {
+        subscriptions.forEach((_, clientNames) -> clientNames.remove(remover));
+    }
+
+    // TODO move server internal code to here
+    @Override
+    public ImmutablePair<String, String> get(String getter) {
+        String foundKey = null;
+        String foundName = null;
+
+        for (var key : subscriptions.keySet()) {
+            var a = subscriptions.get(key).stream().filter(e -> e.equals(getter)).toList();
+            if (!a.isEmpty()) {
+                foundKey = key;
+                foundName = a.getFirst();
+                break;
+            }
+        }
+
+        return new ImmutablePair<>(foundKey, foundName);
+
+    }
+
+    @Override
+    public Collection<ImmutablePair<String, String>> all() {
+        List<ImmutablePair<String, String>> a = new ArrayList<>();
+
+        for (var key : subscriptions.keySet()) {
+            for (var sub : subscriptions.get(key)) {
+                a.addLast(new ImmutablePair<>(key, sub));
+            }
+        }
+
+        return a;
+
+    }
+
+    @Override
+    public Collection<String> allKeys() {
+        return subscriptions.keySet();
+    }
+
+    @Override
+    public Collection<String> allValues(String key) {
+        return subscriptions.get(key);
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/stores/NettyClientStore.java

@@ -0,0 +1,34 @@
+package org.toop.framework.networking.server.stores;
+
+import org.toop.framework.networking.server.client.NettyClient;
+
+import java.util.Collection;
+import java.util.Map;
+
+public class NettyClientStore implements ClientStore<Long, NettyClient> {
+    final private Map<Long, NettyClient> users;
+
+    public NettyClientStore(Map<Long, NettyClient> usersMap) {
+        this.users = usersMap;
+    }
+
+    @Override
+    public void add(NettyClient adding) {
+        users.putIfAbsent(adding.id(), adding);
+    }
+
+    @Override
+    public void remove(Long remover) {
+        users.remove(remover);
+    }
+
+    @Override
+    public NettyClient get(Long getter) {
+        return users.get(getter);
+    }
+
+    @Override
+    public Collection<NettyClient> all() {
+        return users.values();
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/stores/Store.java

@@ -0,0 +1,10 @@
+package org.toop.framework.networking.server.stores;
+
+import java.util.Collection;
+
+public interface Store<IDENTIFIER, STORED> {
+    void add(STORED adding);
+    void remove(IDENTIFIER remover);
+    STORED get(IDENTIFIER getter);
+    Collection<STORED> all();
+}

framework/src/main/java/org/toop/framework/networking/server/stores/SubscriptionStore.java

@@ -0,0 +1,10 @@
+package org.toop.framework.networking.server.stores;
+
+import org.toop.framework.utils.ImmutablePair;
+
+import java.util.Collection;
+
+public interface SubscriptionStore extends Store<String, ImmutablePair<String, String>> {
+    Collection<String> allKeys();
+    Collection<String> allValues(String key);
+}

framework/src/main/java/org/toop/framework/networking/server/stores/TurnBasedGameStore.java

@@ -0,0 +1,36 @@
+package org.toop.framework.networking.server.stores;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.networking.server.OnlineGame;
+
+import java.util.Collection;
+import java.util.List;
+
+public class TurnBasedGameStore implements GameStore<OnlineGame<TurnBasedGame>, OnlineGame<TurnBasedGame>> {
+
+    private List<OnlineGame<TurnBasedGame>> gameList;
+
+    public TurnBasedGameStore(List<OnlineGame<TurnBasedGame>> initGameList) {
+        this.gameList = initGameList;
+    }
+
+    @Override
+    public void add(OnlineGame<TurnBasedGame> adding) {
+        gameList.addLast(adding);
+    }
+
+    @Override
+    public void remove(OnlineGame<TurnBasedGame> remover) {
+        gameList.remove(remover);
+    }
+
+    @Override
+    public OnlineGame<TurnBasedGame> get(OnlineGame<TurnBasedGame> getter) {
+        return gameList.stream().filter(game->game.equals(getter)).findFirst().orElse(null);
+    }
+
+    @Override
+    public Collection<OnlineGame<TurnBasedGame>> all() {
+        return gameList;
+    }
+}

framework/src/main/java/org/toop/framework/networking/server/stores/TurnBasedGameTypeStore.java

@@ -0,0 +1,32 @@
+package org.toop.framework.networking.server.stores;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
+
+public class TurnBasedGameTypeStore {
+
+    private final Map<String, Supplier<? extends TurnBasedGame>> gameFactories = new ConcurrentHashMap<>();
+
+    public TurnBasedGameTypeStore() {}
+
+    public void register(String key, Supplier<? extends TurnBasedGame> factory) {
+        gameFactories.put(key, factory);
+    }
+
+    public void unregister(String key) {
+        gameFactories.remove(key);
+    }
+
+    public TurnBasedGame create(String key) {
+        Supplier<? extends TurnBasedGame> factory = gameFactories.get(key);
+        if (factory == null) throw new IllegalArgumentException("Unknown game type: " + key);
+        return factory.get();
+    }
+
+    public Map<String, Supplier<? extends TurnBasedGame>> all() {
+        return Map.copyOf(gameFactories);
+    }
+}