Fixed hasArgs

# Conflicts:
#	app/src/main/java/org/toop/app/canvas/ReversiBitCanvas.java
#	app/src/main/java/org/toop/app/canvas/TicTacToeBitCanvas.java
#	framework/src/main/java/org/toop/framework/game/games/reversi/BitboardReversi.java
#	framework/src/main/java/org/toop/framework/game/games/tictactoe/BitboardTicTacToe.java

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,8 +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.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;
@@ -27,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;
@@ -137,7 +135,6 @@ public final class App extends Application {
 		}
 
 		stage.show();
-
     }
 
 	private void setKeybinds(StackPane root) {

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

@@ -14,14 +14,14 @@ import org.toop.framework.eventbus.EventFlow;
 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.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.game.games.reversi.BitboardReversi;
+import org.toop.framework.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.framework.game.players.ArtificialPlayer;
+import org.toop.framework.game.players.OnlinePlayer;
+import org.toop.framework.game.players.RandomAI;
 import org.toop.local.AppContext;
 
 import java.util.List;
@@ -214,15 +214,15 @@ public final class Server {
 
             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);
+                        Player[] players = new Player[2];
+                        players[(myTurn + 1) % 2] = new OnlinePlayer(response.opponent());
+                        players[myTurn] = new ArtificialPlayer(new RandomAI(), user);
                         gameController = new TicTacToeBitController(players);
                 }
                 case REVERSI -> {
-                    Player<BitboardReversi>[] players = new Player[2];
-                    players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
-                    players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), user);
+                    Player[] players = new Player[2];
+                    players[(myTurn + 1) % 2] = new OnlinePlayer(response.opponent());
+                    players[myTurn] = new ArtificialPlayer(new RandomAI(), user);
                     gameController = new ReversiBitController(players);}
                 default -> new ErrorPopup("Unsupported game type.");
 
@@ -263,7 +263,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);
 		});

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 &&

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

@@ -1,8 +1,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 extends GameDrawer{
     Canvas getCanvas();
 }

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

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

@@ -15,10 +15,10 @@ 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,13 +28,13 @@ 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) {
+    public GenericGameController(GameCanvas canvas, TurnBasedGame game, ThreadBehaviour gameThreadBehaviour, String gameType) {
         logger.info("Creating: " + this.getClass());
 
         this.canvas = canvas;
@@ -55,7 +55,9 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         // Listen to updates
         eventFlow
                 .listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
-                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setMove(event.move());}}, false);
+                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {
+                    if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}
+                    }, false);
     }
 
     public void start(){
@@ -70,7 +72,7 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         gameThreadBehaviour.stop();
     }
 
-    public Player<T> getCurrentPlayer(){
+    public Player getCurrentPlayer(){
         return game.getPlayer(getCurrentPlayerIndex());
     }
 
@@ -97,7 +99,7 @@ public class GenericGameController<T extends TurnBasedGame<T>> implements GameCo
         stop();
     }
 
-    public Player<T> getPlayer(int player){
+    public Player getPlayer(int player){
         if (player < 0 || player >= 2){ // 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,18 +3,19 @@ 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;
 
-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);
+public class ReversiBitController extends GenericGameController {
+    public ReversiBitController(Player[] players) {
+        BitboardReversi game = new BitboardReversi();
+        game.init(players);
+        ThreadBehaviour thread = new LocalThreadBehaviour(game);
+        for (Player player : players) {
+            if (player instanceof OnlinePlayer){
+                thread = new OnlineThreadBehaviour(game);
             }
         }
         super(new ReversiBitCanvas(), game, thread, "Reversi");

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

@@ -3,19 +3,19 @@ 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);
+public class TicTacToeBitController extends GenericGameController {
+    public TicTacToeBitController(Player[] players) {
+        BitboardTicTacToe game = new BitboardTicTacToe();
+        game.init(players);
+        ThreadBehaviour thread = new LocalThreadBehaviour(game);
+        for (Player player : players) {
+            if (player instanceof OnlinePlayer){
+                thread = new OnlineThreadBehaviour(game);
             }
         }
         super(new TicTacToeBitCanvas(), game, thread , "TicTacToe");

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

@@ -2,24 +2,21 @@ package org.toop.app.widget.view;
 
 import javafx.application.Platform;
 import org.toop.app.GameInformation;
-import org.toop.app.canvas.ReversiBitCanvas;
-import org.toop.app.canvas.TicTacToeBitCanvas;
-import org.toop.app.gameControllers.GenericGameController;
 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.games.reversi.BitboardReversi;
+import org.toop.framework.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.framework.game.players.ArtificialPlayer;
+import org.toop.framework.game.players.LocalPlayer;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.PlayerInfoWidget;
 import org.toop.app.widget.complex.ViewWidget;
 import org.toop.app.widget.popup.ErrorPopup;
 import org.toop.app.widget.tutorial.*;
-import org.toop.game.players.MiniMaxAI;
-import org.toop.game.players.RandomAI;
+import org.toop.framework.game.players.MiniMaxAI;
+import org.toop.framework.game.players.RandomAI;
 import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
@@ -27,9 +24,6 @@ import javafx.scene.control.ScrollPane;
 import javafx.scene.layout.VBox;
 import org.toop.local.AppSettings;
 
-import java.util.Arrays;
-import java.util.Random;
-
 public class LocalMultiplayerView extends ViewWidget {
 	private final GameInformation information;
 
@@ -58,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 RandomAI(), "Random 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(
@@ -86,14 +80,14 @@ 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(), "Random 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 MiniMaxAI(6), "MiniMax");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(

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

@@ -6,6 +6,13 @@ 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.MasterServer;
+
+import java.time.Duration;
+import java.util.concurrent.ConcurrentHashMap;
 
 public class OnlineView extends ViewWidget {
 	public OnlineView() {
@@ -23,6 +30,28 @@ public class OnlineView extends ViewWidget {
 			);
 		});
 
+		var localHostButton = Primitive.button("host!", () -> {
+			var games = new ConcurrentHashMap<String, Class<? extends TurnBasedGame>>();
+			games.put("tic-tac-toe", BitboardTicTacToe.class);
+			games.put("reversi", BitboardReversi.class);
+
+			var a = new MasterServer(6666, games, Duration.ofSeconds(10));
+
+			new Thread(() -> {
+				try {
+					a.start();
+				} catch (InterruptedException e) {
+					throw new RuntimeException(e);
+				}
+			}).start();
+
+			new Server(
+					"127.0.0.1",
+					"6666",
+					"host"
+			);
+		}, false);
+
 		add(Pos.CENTER, Primitive.vbox(
 			serverInformationHeader,
 			Primitive.separator(),
@@ -32,7 +61,9 @@ public class OnlineView extends ViewWidget {
 			playerNameInput.getNode(),
 			Primitive.separator(),
 
-			connectButton
+			connectButton,
+			Primitive.separator(),
+			localHostButton
 		));
 	}
 }

framework/pom.xml

@@ -147,7 +147,6 @@
             <version>2.42.0</version>
         </dependency>
 	</dependencies>
-
 	<build>
 		<plugins>
 			<plugin>

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

@@ -1,39 +1,44 @@
-package org.toop.game;
+package org.toop.framework.game;
 
 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;
+    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.playerBitboard = new long[playerCount];
+	}
+
+	@Override
+	public void init(Player[] players) {
+		this.players = players;
 
 		Arrays.fill(playerBitboard, 0L);
 	}
 
-	public BitboardGame(BitboardGame<T> other) {
+	public BitboardGame(BitboardGame other) {
 		this.columnSize = other.columnSize;
 		this.rowSize = other.rowSize;
-
+        this.playerCount = other.playerCount;
 		this.playerBitboard = other.playerBitboard.clone();
 		this.currentTurn = other.currentTurn;
         this.players = Arrays.stream(other.players)
-                .map(Player<T>::deepCopy)
+                .map(Player::deepCopy)
                 .toArray(Player[]::new);
 	}
 
@@ -61,7 +66,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,7 +76,7 @@ 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()];
     }
 

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,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;
@@ -6,7 +6,7 @@ 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.player.Player;
-import org.toop.game.players.OnlinePlayer;
+import org.toop.framework.game.players.OnlinePlayer;
 
 /**
  * Handles online multiplayer game logic.
@@ -14,17 +14,17 @@ 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 {
     /**
      * 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;

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,72 @@
+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 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 Consumer<ImmutablePair<String, Integer>> onPlayerMove;
+    /**
+     * 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) {
+        super(game);
+    }
+
+    private void notifyPlayerMove(ImmutablePair<String, Integer> pair) {
+        onPlayerMove.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();
+
+            if (state != TURN_SKIPPED){
+                notifyPlayerMove(new ImmutablePair<>(currentPlayer.getName(), Long.numberOfTrailingZeros(move)));
+            }
+
+            switch (state) {
+                case WIN, DRAW -> {
+                    isRunning.set(false);
+                }
+                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

@@ -1,20 +1,25 @@
-package org.toop.game.games.reversi;
+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.game.BitboardGame;
+import org.toop.framework.game.BitboardGame;
 
-public class BitboardReversi extends BitboardGame<BitboardReversi> {
+public class BitboardReversi extends BitboardGame {
 
     public record Score(int black, int white) {}
 
 	private final long notAFile = 0xfefefefefefefefeL;
 	private final long notHFile = 0x7f7f7f7f7f7f7f7fL;
 
-	public BitboardReversi(Player<BitboardReversi>[] players) {
-		super(8, 8, 2, players);
+	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)));
 

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);
     }

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

@@ -1,4 +1,4 @@
-package org.toop.game.players;
+package org.toop.framework.game.players;
 
 import org.toop.framework.gameFramework.model.player.*;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
@@ -12,22 +12,22 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
  *
  * @param <T> the specific type of game this AI player can play
  */
-public class ArtificialPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+public class ArtificialPlayer extends AbstractPlayer {
 
     /** The AI instance used to calculate moves. */
-    private final AI<T> ai;
+    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<T> ai, String name) {
+    public ArtificialPlayer(AI ai, String name) {
         super(name);
         this.ai = ai;
     }
 
-    public ArtificialPlayer(ArtificialPlayer<T> other) {
+    public ArtificialPlayer(ArtificialPlayer other) {
         super(other);
         this.ai = other.ai.deepCopy();
     }
@@ -44,12 +44,12 @@ public class ArtificialPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer
      * @return the integer representing the chosen move
      * @throws ClassCastException if {@code gameCopy} is not of type {@code T}
      */
-    public long getMove(T gameCopy) {
+    public long getMove(TurnBasedGame gameCopy) {
         return ai.getMove(gameCopy);
     }
 
     @Override
-    public ArtificialPlayer<T> deepCopy() {
-        return new ArtificialPlayer<T>(this);
+    public ArtificialPlayer deepCopy() {
+        return new ArtificialPlayer(this);
     }
 }

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

@@ -1,13 +1,12 @@
-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;
-import org.toop.framework.gameFramework.model.player.Player;
 
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
 
-public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+public class LocalPlayer extends AbstractPlayer {
     // Future can be used with event system, IF unsubscribeAfterSuccess works...
     // private CompletableFuture<Integer> LastMove = new CompletableFuture<>();
 
@@ -17,12 +16,12 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
         super(name);
     }
 
-    public LocalPlayer(LocalPlayer<T> other) {
+    public LocalPlayer(LocalPlayer other) {
         super(other);
     }
 
     @Override
-    public long getMove(T gameCopy) {
+    public long getMove(TurnBasedGame gameCopy) {
         return getValidMove(gameCopy);
     }
 
@@ -36,7 +35,7 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
         return false;
     }
 
-    private long getMove2(T gameCopy) {
+    private long getMove2(TurnBasedGame gameCopy) {
         LastMove = new CompletableFuture<>();
         long move = 0;
         try {
@@ -49,7 +48,7 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
         return move;
     }
 
-    protected long getValidMove(T gameCopy){
+    protected long getValidMove(TurnBasedGame gameCopy){
         // Get this player's valid moves
         long validMoves = gameCopy.getLegalMoves();
         // Make sure provided move is valid
@@ -64,8 +63,8 @@ public class LocalPlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
     }
 
     @Override
-    public LocalPlayer<T> deepCopy() {
-        return new LocalPlayer<T>(this.getName());
+    public LocalPlayer deepCopy() {
+        return new LocalPlayer(this.getName());
     }
 
     /*public void register() {

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

@@ -1,4 +1,4 @@
-package org.toop.game.players;
+package org.toop.framework.game.players;
 
 import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.PlayResult;
@@ -9,7 +9,7 @@ import java.util.ArrayList;
 import java.util.List;
 import java.util.Random;
 
-public class MiniMaxAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
+public class MiniMaxAI extends AbstractAI {
 
     private final int maxDepth;
     private final Random random = new Random();
@@ -18,17 +18,17 @@ public class MiniMaxAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
         this.maxDepth = depth;
     }
 
-    public MiniMaxAI(MiniMaxAI<T> other) {
+    public MiniMaxAI(MiniMaxAI other) {
         this.maxDepth = other.maxDepth;
     }
 
     @Override
-    public MiniMaxAI<T> deepCopy() {
-        return new MiniMaxAI<>(this);
+    public MiniMaxAI deepCopy() {
+        return new MiniMaxAI(this);
     }
 
     @Override
-    public long getMove(T game) {
+    public long getMove(TurnBasedGame game) {
         long legalMoves = game.getLegalMoves();
         if (legalMoves == 0) return 0;
 
@@ -39,7 +39,7 @@ public class MiniMaxAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
         long movesLoop = legalMoves;
         while (movesLoop != 0) {
             long move = 1L << Long.numberOfTrailingZeros(movesLoop);
-            T copy = game.deepCopy();
+            TurnBasedGame copy = game.deepCopy();
             PlayResult result = copy.play(move);
 
             int score;
@@ -75,7 +75,7 @@ public class MiniMaxAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
      * @param beta       Beta value
      * @return score of the position
      */
-    private int getMoveScore(T game, int depth, boolean maximizing, int aiPlayer, int alpha, int beta) {
+    private int getMoveScore(TurnBasedGame game, int depth, boolean maximizing, int aiPlayer, int alpha, int beta) {
         long legalMoves = game.getLegalMoves();
 
         // Terminal state
@@ -95,7 +95,7 @@ public class MiniMaxAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
 
         while (movesLoop != 0) {
             long move = 1L << Long.numberOfTrailingZeros(movesLoop);
-            T copy = game.deepCopy();
+            TurnBasedGame copy = game.deepCopy();
             PlayResult result = copy.play(move);
 
             int score;
@@ -130,7 +130,7 @@ public class MiniMaxAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
      * @param aiPlayer AI's player index
      * @return heuristic score
      */
-    private int evaluateBoard(T game, int aiPlayer) {
+    private int evaluateBoard(TurnBasedGame game, int aiPlayer) {
         long[] board = game.getBoard();
         int aiCount = 0;
         int opponentCount = 0;

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;
@@ -12,7 +12,7 @@ import org.toop.framework.gameFramework.model.player.Player;
  * Currently, this class is a placeholder and does not implement move logic.
  * </p>
  */
-public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+public class OnlinePlayer extends AbstractPlayer {
 
     /**
      * Constructs a new OnlinePlayer.
@@ -25,12 +25,12 @@ public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T>
         super(name);
     }
 
-    public OnlinePlayer(OnlinePlayer<T> other) {
+    public OnlinePlayer(OnlinePlayer other) {
         super(other);
     }
 
     @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/RandomAI.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.AbstractAI;
@@ -6,19 +6,19 @@ import org.toop.framework.gameFramework.model.player.AbstractAI;
 import java.util.Random;
 
 
-public class RandomAI<T extends TurnBasedGame<T>> extends AbstractAI<T> {
+public class RandomAI extends AbstractAI {
 
     public RandomAI() {
         super();
     }
 
     @Override
-    public RandomAI<T> deepCopy() {
-        return new RandomAI<T>();
+    public RandomAI deepCopy() {
+        return new RandomAI();
     }
 
     @Override
-    public long getMove(T game) {
+    public long getMove(TurnBasedGame game) {
         long legalMoves = game.getLegalMoves();
         int move = new Random().nextInt(Long.bitCount(legalMoves));
         return nthBitIndex(legalMoves, move);

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

@@ -0,0 +1,46 @@
+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.User;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+public class ServerPlayer extends AbstractPlayer {
+    private User user;
+    private CompletableFuture<Long> lastMove;
+
+    public ServerPlayer(User user) {
+        super(user.name());
+        this.user = user;
+    }
+
+    public void setMove(long move) {
+        lastMove.complete(move);
+    }
+
+    @Override
+    public Player deepCopy() {
+        return null;
+    }
+
+    @Override
+    public long getMove(TurnBasedGame game) {
+        lastMove = new CompletableFuture<>();
+        System.out.println("Sending yourturn");
+        user.sendMessage("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}\n");
+        try {
+            return lastMove.get();
+        } catch (InterruptedException | ExecutionException e) {
+            e.printStackTrace();
+            return 0;
+        }
+    }
+
+    @Override
+    public String getName() {
+        return "";
+    }
+}

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

@@ -1,8 +1,7 @@
 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 {
     /** Called when it is this player's turn to make a move. */

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

@@ -2,6 +2,6 @@ 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);
+public interface PlayerProvider {
+    Player getPlayer(int index);
 }

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

@@ -1,7 +1,5 @@
 package org.toop.framework.gameFramework.model.game;
 
-import org.toop.framework.networking.events.NetworkEvents;
-
 /**
  * Interface for games that support online multiplayer play.
  * <p>

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

@@ -1,6 +1,9 @@
 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 Playable, PlayerProvider, BoardProvider, DeepCopyable<TurnBasedGame> {
+    void init(Player[] players);
     int getCurrentTurn();
     int getPlayerCount();
     int getWinner();

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

@@ -16,14 +16,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 +33,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/player/AI.java

@@ -3,5 +3,5 @@ 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 MoveProvider, DeepCopyable<AI> {
 }

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

@@ -15,7 +15,7 @@ import org.toop.framework.gameFramework.model.game.TurnBasedGame;
  * 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;
@@ -24,7 +24,7 @@ public abstract class AbstractPlayer<T extends TurnBasedGame<T>> implements Play
         this.name = name;
     }
 
-    protected AbstractPlayer(AbstractPlayer<T> other) {
+    protected AbstractPlayer(AbstractPlayer other) {
         this.name = other.name;
     }
     /**
@@ -39,7 +39,7 @@ public abstract class AbstractPlayer<T extends TurnBasedGame<T>> implements Play
      * @return an integer representing the chosen move
      * @throws UnsupportedOperationException if the method is not overridden
      */
-    public long getMove(T gameCopy) {
+    public long getMove(TurnBasedGame gameCopy) {
         logger.error("Method getMove not implemented.");
         throw new UnsupportedOperationException("Not supported yet.");
     }

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

@@ -2,6 +2,6 @@ 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);
+public interface MoveProvider {
+    long getMove(TurnBasedGame game);
 }

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

@@ -1,7 +1,5 @@
 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 NameProvider, MoveProvider, DeepCopyable<Player> {}

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,9 @@ 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.exceptions.CouldNotConnectException;
+import org.toop.framework.networking.connection.handlers.NetworkingGameClientHandler;
+import org.toop.framework.networking.connection.interfaces.NetworkingClient;
 
 import java.net.InetSocketAddress;
 

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.
@@ -102,7 +102,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. */

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,4 +1,4 @@
-package org.toop.framework.networking.handlers;
+package org.toop.framework.networking.connection.handlers;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
@@ -9,7 +9,7 @@ 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);

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

@@ -0,0 +1,155 @@
+package org.toop.framework.networking.server;
+
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.SimpleChannelInboundHandler;
+import org.apache.maven.surefire.shared.utils.StringUtils;
+
+import java.util.Arrays;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
+
+public class ConnectionHandler extends SimpleChannelInboundHandler<String> {
+
+    private final User user;
+    private final Server server;
+
+    public ConnectionHandler(User user, Server server) {
+        this.user = user;
+        this.server = server;
+    }
+
+    private String returnQuotedString(Iterator<String> strings) { // TODO more places this could be useful
+        return "\"" + StringUtils.join(strings, "\",\"") + "\"";
+    }
+
+    @Override
+    public void channelActive(ChannelHandlerContext ctx) {
+        ctx.writeAndFlush("WELCOME " + user.id() + "\n");
+
+        user.setCtx(ctx);
+        server.addUser(user); // TODO set correct name on login
+    }
+
+    @Override
+    protected void channelRead0(ChannelHandlerContext ctx, String msg) {
+
+        IO.println(msg);
+
+        ParsedMessage p = parse(msg);
+        if (p == null) return;
+
+        IO.println(p.command() + " " + Arrays.toString(p.args()));
+
+        switch (p.command()) {
+            case "ping" -> ctx.writeAndFlush("PONG\n");
+            case "login" -> handleLogin(p);
+            case "get" -> handleGet(p);
+            case "subscribe" -> handleSubscribe(p);
+            case "move" -> handleMove(p);
+            case "challenge" -> handleChallenge(p);
+            case "message" -> handleMessage(p);
+            case "help" -> handleHelp(p);
+            default -> ctx.writeAndFlush("ERROR Unknown command\n");
+        }
+    }
+
+    // DO NOT INVERT
+    private boolean hasArgs(String... args) {
+        return (args.length >= 1);
+    }
+
+    private void handleLogin(ParsedMessage p) {
+        if (!hasArgs(p.args())) return;
+
+        user.setName(p.args()[0]);
+    }
+
+    private void handleGet(ParsedMessage p) {
+        if (!hasArgs(p.args())) return;
+
+        switch (p.args()[0]) {
+            case "playerlist" -> {
+                var names = server.onlineUsers().stream().map(ServerUser::name).iterator();
+                user.ctx().writeAndFlush("SVR PLAYERLIST " + returnQuotedString(names) + "\n");
+            }
+            case "gamelist" -> {
+                var names = server.gameTypes().stream().iterator();
+                user.ctx().writeAndFlush("SVR GAMELIST " + returnQuotedString(names) + "\n");
+            }
+        }
+    }
+
+    private void handleSubscribe(ParsedMessage p) {
+        // TODO
+    }
+
+    private void handleHelp(ParsedMessage p) {
+        // TODO
+    }
+
+    private void handleMessage(ParsedMessage p) {
+        // TODO
+    }
+
+    private void handleChallenge(ParsedMessage p) {
+        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) {
+                    user.sendMessage("ERR id must be a positive number \n");
+                    return;
+                }
+
+                server.acceptChallenge(id);
+
+            } catch (NumberFormatException e) {
+                user.sendMessage("ERR id is not a valid number or too big \n");
+                return;
+            }
+            return;
+        }
+
+        server.challengeUser(user.name(), p.args()[0], p.args()[1]);
+    }
+
+    private void handleMove(ParsedMessage p) {
+        if(!hasArgs(p.args())) return;
+
+        // TODO check if not number
+        user.serverPlayer().setMove(1L << Integer.parseInt(p.args()[0]));
+    }
+
+    private 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);
+        }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
+        cause.printStackTrace();
+        ctx.close();
+    }
+
+    @Override
+    public void channelInactive(ChannelHandlerContext ctx) {
+        server.removeUser(user);
+    }
+}

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

@@ -0,0 +1,43 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.game.gameThreads.ServerThreadBehaviour;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+public class Game implements OnlineGame<TurnBasedGame> {
+
+    private long id;
+    private User[] users;
+    private TurnBasedGame game;
+    private ServerThreadBehaviour gameThread;
+
+    public Game(TurnBasedGame game, User... users) {
+        this.game = game;
+        this.gameThread = new ServerThreadBehaviour(game, (pair) -> notifyMoveMade(pair.getLeft(), pair.getRight()));
+        this.users = users;
+    }
+
+    private void notifyMoveMade(String speler, int move){
+        users[0].sendMessage(String.format("SVR GAME MOVE {PLAYER: \"%s\", DETAILS: \"<reactie spel op zet>\", MOVE: \"%s\"}", speler, move));
+        users[1].sendMessage(String.format("SVR GAME MOVE {PLAYER: \"%s\", DETAILS: \"<reactie spel op zet>\", MOVE: \"%s\"}", speler, move));
+    }
+
+    @Override
+    public long id() {
+        return id;
+    }
+
+    @Override
+    public TurnBasedGame game() {
+        return game;
+    }
+
+    @Override
+    public User[] users() {
+        return users;
+    }
+
+    @Override
+    public void start(){
+        this.gameThread.start();
+    }
+}

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

@@ -0,0 +1,47 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.SnowflakeGenerator;
+
+public class GameChallenge {
+    private final long id = SnowflakeGenerator.nextId(); // I don't need this, but the tournament server uses it...
+
+    private final User from;
+    private final User to;
+    private final String gameType;
+    private final SimpleTimer timer;
+
+    private boolean isChallengeAccepted = false;
+
+    public GameChallenge(User from, User to, String gameType, SimpleTimer timer) {
+        this.from = from;
+        this.to = to;
+        this.gameType = gameType;
+        this.timer = timer;
+    }
+
+    public long id() {
+        return id;
+    }
+
+    public User[] getUsers() {
+        return new User[]{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/GameChallengeTimer.java

@@ -0,0 +1,33 @@
+package org.toop.framework.networking.server;
+
+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/GameDefinition.java

@@ -0,0 +1,28 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+import java.lang.reflect.InvocationTargetException;
+
+public class GameDefinition<T> {
+    private final String name;
+    private final Class<T> game;
+
+    public GameDefinition(String name, Class<T> game) {
+        this.name = name;
+        this.game = game;
+    }
+
+    public String name() {
+        return name;
+    }
+
+    public T create(String... users) {
+        try {
+            return game.getDeclaredConstructor().newInstance(users);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+}

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

@@ -0,0 +1,8 @@
+package org.toop.framework.networking.server;
+
+public interface GameServer {
+//    List<?> gameTypes();
+//    List<?> ongoingGames();
+//    void startGame(String gameType, User... users);
+//    String[] onlineUsers();
+}

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

@@ -0,0 +1,69 @@
+package org.toop.framework.networking.server;
+
+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 java.time.Duration;
+import java.util.Map;
+
+public class MasterServer {
+    private final int port;
+    public final Server gs;
+
+    public MasterServer(int port, Map<String, Class<? extends TurnBasedGame>> gameTypes, Duration challengeDuration) {
+        this.port = port;
+        this.gs = new Server(gameTypes, challengeDuration);
+    }
+
+    public void start() throws InterruptedException {
+
+        EventLoopGroup bossGroup = new NioEventLoopGroup(1);
+        EventLoopGroup 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();
+                            User user = new User(userid, ""+userid);
+                            pipeline.addLast(new ConnectionHandler(user, gs));
+                        }
+                    }
+            );
+
+            ChannelFuture future = bootstrap.bind(port).sync();
+            System.out.println("MasterServer listening on port " + port);
+
+            future.channel().closeFuture().sync();
+        } finally {
+            bossGroup.shutdownGracefully();
+            workerGroup.shutdownGracefully();
+        }
+    }
+}

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

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server;
+
+public interface MessageStore {
+    void add(String message);
+    String get();
+    void reset();
+}

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

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

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

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

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

@@ -0,0 +1,4 @@
+package org.toop.framework.networking.server;
+
+public class Parser {
+}

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

@@ -0,0 +1,4 @@
+package org.toop.framework.networking.server;
+
+public interface ServableGame {
+}

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

@@ -0,0 +1,182 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.game.players.ServerPlayer;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.utils.ImmutablePair;
+
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.*;
+import java.time.Duration;
+
+public class Server implements GameServer {
+
+    final private Map<String, Class<? extends TurnBasedGame>> gameTypes;
+    final private Map<Long, User> users = new ConcurrentHashMap<>();
+    final private List<GameChallenge> gameChallenges = new CopyOnWriteArrayList<>();
+    final private List<OnlineGame<TurnBasedGame>> games = new CopyOnWriteArrayList<>();
+
+    final private Duration challengeDuration;
+    final private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
+
+    public Server(Map<String, Class<? extends TurnBasedGame>> gameTypes, Duration challengeDuration) {
+        this.gameTypes = gameTypes;
+        this.challengeDuration = challengeDuration;
+
+        scheduler.schedule(this::serverTask, 0, TimeUnit.MILLISECONDS);
+    }
+
+    private void serverTask() {
+        checkChallenges();
+        scheduler.schedule(this::serverTask, 500, TimeUnit.MILLISECONDS);
+    }
+
+    public void addUser(User user) {
+        users.putIfAbsent(user.id(), user);
+    }
+
+    public void removeUser(User user) {
+        users.remove(user.id());
+    }
+
+    public List<String> gameTypes() {
+        return gameTypes.keySet().stream().toList();
+    }
+
+    public List<OnlineGame<TurnBasedGame>> ongoingGames() {
+        return games;
+    }
+
+    public User getUser(String username) {
+        return users.values().stream().filter(e -> e.name().equalsIgnoreCase(username)).findFirst().orElse(null);
+    }
+
+    public User getUser(long id) {
+        return users.get(id);
+    }
+
+    public void challengeUser(String fromUser, String toUser, String gameType) {
+
+        User from = getUser(fromUser);
+        if (from == null) {
+            return;
+        }
+
+        if (!gameTypes.containsKey(gameType)) {
+            from.sendMessage("ERR gametype not found \n");
+            return;
+        }
+
+        User to = getUser(toUser);
+        if (to == null) {
+            from.sendMessage("ERR user not found \n");
+            return;
+        }
+
+        var ch = new GameChallenge(from, to, gameType, new GameChallengeTimer(challengeDuration));
+
+        to.sendMessage(
+                "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);
+    }
+
+    private void warnUserExpiredChallenge(User user, long challengeId) {
+        user.sendMessage("SVR GAME CHALLENGE CANCELLED {CHALLENGENUMBER: \"" + challengeId + "\"}" + "\n");
+    }
+
+    private boolean isValidChallenge(GameChallenge gameChallenge) {
+        for (var user : gameChallenge.getUsers()) {
+            if (users.get(user.id()) == null) {
+                return false;
+            }
+
+            if (user.game() != null) {
+                return false;
+            }
+
+            if (gameChallenge.isExpired()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public 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);
+            }
+        }
+    }
+
+    public void acceptChallenge(long challengeId) {
+        for (var challenge : gameChallenges) {
+            if (challenge.id() == challengeId) {
+                startGame(challenge.acceptChallenge(), challenge.getUsers());
+                break;
+            }
+        }
+    }
+
+    public List<GameChallenge> gameChallenges() {
+        return gameChallenges;
+    }
+
+    public void startGame(String gameType, User... users) {
+        if (!gameTypes.containsKey(gameType)) return;
+
+        try {
+            ServerPlayer[] players = new ServerPlayer[users.length];
+            var game = new Game(gameTypes.get(gameType).getDeclaredConstructor().newInstance(), users);
+
+            for (int i = 0; i < users.length; i++) {
+                players[i] = new ServerPlayer(users[i]);
+                users[i].addGame(new ImmutablePair<>(game, players[i]));
+            }
+            System.out.println("Starting Game");
+
+            game.game().init(players);
+            games.addLast(game);
+
+            users[0].sendMessage(String.format("SVR GAME MATCH {PLAYERTOMOVE: \"%s\", GAMETYPE: \"%s\", OPPONENT: \"%s\"}\n",
+                    users[0].name(),
+                    gameType,
+                    users[1].name()));
+            users[1].sendMessage(String.format("SVR GAME MATCH {PLAYERTOMOVE: \"%s\", GAMETYPE: \"%s\", OPPONENT: \"%s\"}\n",
+                    users[0].name(),
+                    gameType,
+                    users[0].name()));
+            game.start();
+        } catch (Exception ignored) {}
+    }
+
+    public List<User> onlineUsers() {
+        return users.values().stream().toList();
+    }
+
+    public void closeServer() {
+        scheduler.shutdown();
+        gameChallenges.clear();
+        games.clear();
+        users.clear();
+        gameTypes.clear();
+    }
+}

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

@@ -0,0 +1,27 @@
+package org.toop.framework.networking.server;
+
+import java.util.Queue;
+
+public class ServerMessageStore implements MessageStore {
+
+    Queue<String> messageQueue;
+
+    public ServerMessageStore(Queue<String> messageQueue) {
+        this.messageQueue = messageQueue;
+    }
+
+    @Override
+    public void add(String message) {
+        messageQueue.offer(message);
+    }
+
+    @Override
+    public String get() {
+        return messageQueue.poll();
+    }
+
+    @Override
+    public void reset() {
+        messageQueue.clear();
+    }
+}

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

@@ -0,0 +1,15 @@
+package org.toop.framework.networking.server;
+
+import org.toop.framework.game.players.ServerPlayer;
+import org.toop.framework.utils.Pair;
+
+public interface ServerUser {
+    long id();
+    String name();
+    Game game();
+    ServerPlayer serverPlayer();
+    void addGame(Pair<Game, ServerPlayer> gamePair);
+    void removeGame();
+    void setName(String name);
+    void sendMessage(String message);
+}

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

@@ -0,0 +1,7 @@
+package org.toop.framework.networking.server;
+
+public interface SimpleTimer {
+    void forceExpire();
+    boolean isExpired();
+    long secondsRemaining();
+}

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

@@ -0,0 +1,69 @@
+package org.toop.framework.networking.server;
+
+import io.netty.channel.ChannelHandlerContext;
+import org.toop.framework.game.players.ServerPlayer;
+import org.toop.framework.utils.Pair;
+
+public class User implements ServerUser {
+    final private long id;
+    private String name;
+    private Pair<Game, ServerPlayer> gamePair;
+    private ChannelHandlerContext connectionContext;
+
+    public User(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 addGame(Pair<Game, ServerPlayer> gamePair) {
+        if (this.gamePair == null) {
+            this.gamePair = gamePair;
+        }
+    }
+
+    @Override
+    public void removeGame() {
+        this.gamePair = null;
+    }
+
+    @Override
+    public Game game() {
+        return this.gamePair.getLeft();
+    }
+
+    public ServerPlayer serverPlayer() {
+        return this.gamePair.getRight();
+    }
+
+    @Override
+    public void setName(String name) {
+        this.name = name;
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        IO.println(message);
+        ctx().channel().writeAndFlush(message);
+    }
+
+    public ChannelHandlerContext ctx() {
+        return connectionContext;
+    }
+
+    public void setCtx(ChannelHandlerContext ctx) {
+        this.connectionContext = ctx;
+    }
+
+
+}

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

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

framework/src/main/java/org/toop/framework/utils/ImmutablePair.java

@@ -0,0 +1,21 @@
+package org.toop.framework.utils;
+
+public class ImmutablePair<T, K> implements Pair<T,K> {
+    final T left;
+    final K right;
+
+    public ImmutablePair(T left, K right) {
+        this.left = left;
+        this.right = right;
+    }
+
+    @Override
+    public T getLeft() {
+        return left;
+    }
+
+    @Override
+    public K getRight() {
+        return right;
+    }
+}

framework/src/main/java/org/toop/framework/utils/MutablePair.java

@@ -0,0 +1,29 @@
+package org.toop.framework.utils;
+
+public class MutablePair<T, K> implements Pair<T,K> {
+    T left;
+    K right;
+
+    public MutablePair(T left, K right) {
+        this.left = left;
+        this.right = right;
+    }
+
+    @Override
+    public T getLeft() {
+        return left;
+    }
+
+    public void setLeft(T left) {
+        this.left = left;
+    }
+
+    @Override
+    public K getRight() {
+        return right;
+    }
+
+    public void setRight(K right) {
+        this.right = right;
+    }
+}

framework/src/main/java/org/toop/framework/utils/Pair.java

@@ -0,0 +1,6 @@
+package org.toop.framework.utils;
+
+public interface Pair<T, K> {
+    T getLeft();
+    K getRight();
+}

framework/src/test/java/org/toop/framework/networking/NetworkingClientManagerTest.java

@@ -9,7 +9,7 @@
 //import org.mockito.*;
 //import org.toop.framework.SnowflakeGenerator;
 //import org.toop.framework.eventbus.EventFlow;
-//import org.toop.framework.networking.events.NetworkEvents;
+//import org.toop.framework.networking.connection.events.NetworkEvents;
 //
 //class NetworkingClientManagerTest {
 //

framework/src/test/java/org/toop/framework/networking/connection/events/NetworkEventsTest.java

@@ -1,4 +1,4 @@
-//package org.toop.framework.networking.events;
+//package org.toop.framework.networking.connection.events;
 //
 //import static org.junit.jupiter.api.Assertions.*;
 //

framework/src/test/java/org/toop/framework/networking/server/ServerTest.java

@@ -0,0 +1,167 @@
+//package org.toop.framework.networking.server;
+//
+//import org.junit.jupiter.api.Assertions;
+//import org.junit.jupiter.api.BeforeEach;
+//import org.junit.jupiter.api.Test;
+//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.time.Duration;
+//import java.util.Arrays;
+//import java.util.concurrent.ConcurrentHashMap;
+//
+//public class ServerTest {
+//
+//    static class TurnBasedGameMock implements TurnBasedGame {
+//        private Player[] players;
+//
+//        public TurnBasedGameMock() {}
+//
+//        @Override
+//        public void init(Player[] players) {
+//            this.players = players;
+//        }
+//
+//        @Override
+//        public int getCurrentTurn() {
+//            return 0;
+//        }
+//
+//        @Override
+//        public int getPlayerCount() {
+//            return 0;
+//        }
+//
+//        @Override
+//        public int getWinner() {
+//            return 0;
+//        }
+//
+//        @Override
+//        public long[] getBoard() {
+//            return new long[0];
+//        }
+//
+//        @Override
+//        public TurnBasedGame deepCopy() {
+//            return null;
+//        }
+//
+//        @Override
+//        public long getLegalMoves() {
+//            return 0;
+//        }
+//
+//        @Override
+//        public PlayResult play(long move) {
+//            return null;
+//        }
+//
+//        @Override
+//        public Player getPlayer(int index) {
+//            return null;
+//        }
+//
+//    }
+//
+//    static class TestUser implements ServerUser {
+//
+//        final private long id;
+//
+//        private String name;
+//
+//        public TestUser(long id, String name) {
+//            this.id = id;
+//            this.name = name;
+//        }
+//
+//        @Override
+//        public long id() {
+//            return id;
+//        }
+//
+//        @Override
+//        public String name() {
+//            return name;
+//        }
+//
+//        @Override
+//        public Game[] games() {
+//            return new Game[0];
+//        }
+//
+//        @Override
+//        public void addGame(Game game) {
+//
+//        }
+//
+//        @Override
+//        public void removeGame(Game game) {
+//
+//        }
+//
+//        @Override
+//        public void setName(String name) {
+//            this.name = name;
+//        }
+//
+//        @Override
+//        public void sendMessage(String message) {
+//
+//        }
+//    }
+//
+//    private Server server;
+//    private Duration waitTime = Duration.ofSeconds(2);
+//
+//    @BeforeEach
+//    void setup() {
+//
+//        var games = new ConcurrentHashMap<String, Class<? extends TurnBasedGame>>();
+//        games.put("tictactoe", TurnBasedGameMock.class);
+//        games.put("reversi", TurnBasedGameMock.class);
+//
+//        server = new Server(games, waitTime);
+//    }
+//
+//    @Test
+//    void testGameTypes() {
+//        String[] expected = {"tictactoe", "reversi"};
+//        String[] actual = server.gameTypes();
+//
+//        Arrays.sort(expected);
+//        Arrays.sort(actual);
+//
+//        Assertions.assertArrayEquals(expected, actual);
+//    }
+//
+//    @Test
+//    void testChallenge() {
+//        server.addUser(new TestUser(1, "test1"));
+//        server.addUser(new TestUser(2, "test2"));
+//        server.challengeUser("test1", "test2", "tictactoe");
+//
+//        IO.println(server.gameChallenges());
+//
+//        Assertions.assertEquals(1, server.gameChallenges().size());
+//
+//        try {
+//            Thread.sleep(waitTime.plusMillis(100));
+//        } catch (InterruptedException e) {
+//            throw new RuntimeException(e);
+//        }
+//
+//        Assertions.assertEquals(0, server.gameChallenges().size());
+//    }
+//
+//    @Test
+//    void testStartGame() {
+//        server.startGame("tictactoe", new User(0, "A"), new User(1, "B"));
+//        Assertions.assertEquals(1, server.ongoingGames().size());
+//        server.startGame("reversi", new User(0, "A"), new User(1, "B"));
+//        Assertions.assertEquals(2, server.ongoingGames().size());
+//    }
+//
+//
+//}

framework/src/test/java/org/toop/framework/networking/server/servertests.ps1

@@ -0,0 +1,17 @@
+$client = New-Object System.Net.Sockets.TcpClient("localhost", 6666)
+$stream = $client.GetStream()
+$writer = New-Object System.IO.StreamWriter($stream)
+$reader = New-Object System.IO.StreamReader($stream)
+
+$client2 = New-Object System.Net.Sockets.TcpClient("localhost", 6666)
+$stream2 = $client2.GetStream()
+$writer2 = New-Object System.IO.StreamWriter($stream2)
+$reader2 = New-Object System.IO.StreamReader($stream2)
+
+$writer.WriteLine("login john")
+$writer.Flush()
+$reader.ReadLine()
+
+$writer2.WriteLine("login hendrik")
+$writer2.Flush()
+$reader2.ReadLine()