update mcts

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

.github/workflows/checks.yaml

@@ -1,42 +1,42 @@
-name: Checks
+#name: Checks
 
-on:
-  push:
-    branches:
-      - 'main'
-  pull_request:
-    branches:
-      - 'main'
+#on:
+#  push:
+#    branches:
+#      - 'main'
+#  pull_request:
+#    branches:
+#      - 'main'
+#
+#jobs:
+#  formatting-check:
+#    name: Follow Google Formatting Guidelines
+#    runs-on: ubuntu-latest
+#    steps:
+#      - uses: actions/checkout@v5
+#        with:
+#          fetch-depth: 0 # Fix for incremental formatting
+#      - uses: actions/setup-java@v5
+#        with:
+#          java-version: '25'
+#          distribution: 'temurin'
+#          cache: maven
+#      - name: Run Format Check
+#        run: mvn spotless:check
 
-jobs:
-  formatting-check:
-    name: Follow Google Formatting Guidelines
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v5
-        with:
-          fetch-depth: 0 # Fix for incremental formatting
-      - uses: actions/setup-java@v5
-        with:
-          java-version: '25'
-          distribution: 'temurin'
-          cache: maven
-      - name: Run Format Check
-        run: mvn spotless:check
-
-  tests:
-    name: Unittests
-    runs-on: ${{ matrix.os }}
-    needs: formatting-check
-    strategy:
-      matrix:
-        os: [ubuntu-latest] #windows-latest, macos-latest
-    steps:
-      - uses: actions/checkout@v5
-      - uses: actions/setup-java@v5
-        with:
-          java-version: '25'
-          distribution: 'temurin'
-          cache: maven
-      - name: Run Unittests
-        run: mvn -B test
+#  tests:
+#    name: Unittests
+#    runs-on: ${{ matrix.os }}
+#    needs: formatting-check
+#    strategy:
+#      matrix:
+#        os: [ubuntu-latest] #windows-latest, macos-latest
+#    steps:
+#      - uses: actions/checkout@v5
+#      - uses: actions/setup-java@v5
+#        with:
+#          java-version: '25'
+#          distribution: 'temurin'
+#          cache: maven
+#      - name: Run Unittests
+#        run: mvn -B test

.idea/inspectionProfiles/Project_Default.xml

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

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

@@ -1,16 +1,68 @@
 package org.toop;
 
 import org.toop.app.App;
-import org.toop.framework.audio.*;
-import org.toop.framework.networking.NetworkingClientEventListener;
-import org.toop.framework.networking.NetworkingClientManager;
-import org.toop.framework.resource.ResourceLoader;
-import org.toop.framework.resource.ResourceManager;
-import org.toop.framework.resource.resources.MusicAsset;
-import org.toop.framework.resource.resources.SoundEffectAsset;
+import org.toop.framework.game.games.reversi.BitboardReversi;
+import org.toop.framework.game.players.ArtificialPlayer;
+import org.toop.game.players.ai.MCTSAI;
+import org.toop.game.players.ai.RandomAI;
+import org.toop.game.players.ai.mcts.MCTSAI1;
+import org.toop.game.players.ai.mcts.MCTSAI2;
+import org.toop.game.players.ai.mcts.MCTSAI3;
+import org.toop.game.players.ai.mcts.MCTSAI4;
+
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
 public final class Main {
     static void main(String[] args) {
-        App.run(args);
+		App.run(args);
+
+		// final ExecutorService executor = Executors.newFixedThreadPool(1);
+		// executor.execute(() -> testAIs(25));
     }
-}
+
+	private static void testAIs(int games) {
+		var versions = new ArtificialPlayer[5];
+		versions[0] = new ArtificialPlayer(new RandomAI(), "Random AI");
+		versions[1] = new ArtificialPlayer(new MCTSAI1(1000), "MCTS V1 AI");
+		versions[2] = new ArtificialPlayer(new MCTSAI2(1000), "MCTS V2 AI");
+		versions[3] = new ArtificialPlayer(new MCTSAI3(10, 10), "MCTS V3 AI");
+		versions[4] = new ArtificialPlayer(new MCTSAI4(10, 10), "MCTS V4 AI");
+
+		for (int i = 0; i < versions.length; i++) {
+			for (int j = i + 1; j < versions.length; j++) {
+				final int playerIndex1 = i % versions.length;
+				final int playerIndex2 = j % versions.length;
+
+				testAIVSAI(games, new ArtificialPlayer[] { versions[playerIndex1], versions[playerIndex2]});
+			}
+		}
+	}
+
+	private static void testAIVSAI(int games, ArtificialPlayer[] ais) {
+		int wins = 0;
+		int ties = 0;
+
+		for (int i = 0; i < games; i++) {
+			final BitboardReversi match = new BitboardReversi();
+			match.init(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,20 +1,27 @@
 package org.toop.app;
 
+import javafx.application.Application;
 import javafx.application.Platform;
-import javafx.scene.paint.Color;
-import org.toop.Main;
+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.Widget;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.complex.LoadingWidget;
 import org.toop.app.widget.display.SongDisplay;
+import org.toop.app.widget.popup.EscapePopup;
 import org.toop.app.widget.popup.QuitPopup;
 import org.toop.app.widget.view.MainView;
 import org.toop.framework.audio.*;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.networking.NetworkingClientEventListener;
-import org.toop.framework.networking.NetworkingClientManager;
+import org.toop.framework.eventbus.GlobalEventBus;
+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;
@@ -24,11 +31,10 @@ 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;
+import java.util.concurrent.Executors;
 
 public final class App extends Application {
 	private static Stage stage;
@@ -37,14 +43,12 @@ public final class App extends Application {
     private static int height;
     private static int width;
 
-	private static boolean isQuitting;
-
 	public static void run(String[] args) {
 		launch(args);
 	}
 
 	@Override
-	public void start(Stage stage) throws Exception {
+	public void start(Stage stage) {
 		// Start loading localization
 		ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/localization"));
 		ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/style"));
@@ -62,8 +66,8 @@ public final class App extends Application {
 
 		scene.getRoot();
 
-        stage.setMinWidth(1080);
-        stage.setMinHeight(720);
+        stage.setMinWidth(1200);
+        stage.setMinHeight(800);
 		stage.setOnCloseRequest(event -> {
 			event.consume();
 			quit();
@@ -78,17 +82,17 @@ public final class App extends Application {
 		App.width = (int)stage.getWidth();
 		App.height = (int)stage.getHeight();
 
-		App.isQuitting = false;
-
 		AppSettings.applySettings();
 
+        setKeybinds(root);
+
         LoadingWidget loading = new LoadingWidget(Primitive.text(
                 "Loading...", false), 0, 0, Integer.MAX_VALUE, false, false // Just set a high default
         );
 
 		WidgetContainer.setCurrentView(loading);
 
-		setOnLoadingSuccess(loading);
+        setOnLoadingSuccess(loading);
 
         EventFlow loadingFlow = new EventFlow();
 
@@ -105,90 +109,142 @@ public final class App extends Application {
 						Platform.runLater(() -> stage.setOpacity(1.0));
 					}
 
-					Platform.runLater(() -> loading.setMaxAmount(e.isLoadingAmount()));
-
 					Platform.runLater(() -> {
+                        loading.setMaxAmount(e.isLoadingAmount());
 						try {
 							loading.setAmount(e.hasLoadedAmount());
 						} catch (Exception ex) {
 							throw new RuntimeException(ex);
 						}
+                        if (e.hasLoadedAmount() >= e.isLoadingAmount()-1) {
+                            Platform.runLater(loading::triggerSuccess);
+                            loadingFlow.unsubscribe("init_loading");
+                        }
 					});
 
-                    if (e.hasLoadedAmount() >= e.isLoadingAmount()) {
-                        Platform.runLater(loading::triggerSuccess);
-                        loadingFlow.unsubscribe("init_loading");
-                    }
 
                 }, false, "init_loading");
 
-		// Start loading assets
-		new Thread(() -> ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets")))
-				.start();
+		ExecutorService executor = Executors.newSingleThreadExecutor();
+		try {
+			executor.submit(
+				() -> ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets")
+			));
+		} finally {
+			executor.shutdown();
+		}
 
 		stage.show();
+    }
 
+	private void setKeybinds(StackPane root) {
+		root.addEventHandler(KeyEvent.KEY_PRESSED,event -> {
+			if (event.getCode() == KeyCode.ESCAPE) {
+				escapePopup();	
+			}
+		});
+        stage.setFullScreenExitKeyCombination(
+                new KeyCodeCombination(
+                        KeyCode.F11
+                )
+        );
+	}
+
+	public void escapePopup() {
+
+		if (   WidgetContainer.getCurrentView() == null
+			|| WidgetContainer.getCurrentView() instanceof MainView) {
+			return;
+		}
+
+		if (!Objects.requireNonNull(
+				WidgetContainer.find(widget -> widget instanceof QuitPopup || widget instanceof EscapePopup)
+		).isEmpty()) {
+			WidgetContainer.removeFirst(QuitPopup.class);
+			WidgetContainer.removeFirst(EscapePopup.class);
+			return;
+		}
+
+		EscapePopup escPopup = new EscapePopup();
+		escPopup.show(Pos.CENTER);
 	}
 
 	private void setOnLoadingSuccess(LoadingWidget loading) {
 		loading.setOnSuccess(() -> {
-			initSystems();
-			AppSettings.applyMusicVolumeSettings();
+
+            try {
+                initSystems();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            AppSettings.applyMusicVolumeSettings();
 			new EventFlow().addPostEvent(new AudioEvents.StartBackgroundMusic()).postEvent();
             loading.hide();
 			WidgetContainer.add(Pos.CENTER, new MainView());
 			WidgetContainer.add(Pos.BOTTOM_RIGHT, new SongDisplay());
 			stage.setOnCloseRequest(event -> {
 				event.consume();
-				startQuit();
+
+				if (WidgetContainer.getAllWidgets().stream().anyMatch(e -> e instanceof QuitPopup)) return;
+
+				QuitPopup a = new QuitPopup();
+				a.show(Pos.CENTER);
+
 			});
 		});
 	}
 
-	private void initSystems() { // TODO Move to better place
-		new Thread(() -> new NetworkingClientEventListener(new NetworkingClientManager())).start();
+	private void initSystems() throws InterruptedException { // TODO Move to better place
 
-		new Thread(() -> {
-			MusicManager<MusicAsset> musicManager =
-					new MusicManager<>(ResourceManager.getAllOfTypeAndRemoveWrapper(MusicAsset.class), true);
+		final int THREAD_COUNT = 2;
+		CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
 
-			SoundEffectManager<SoundEffectAsset> soundEffectManager =
-					new SoundEffectManager<>(ResourceManager.getAllOfType(SoundEffectAsset.class));
+		@SuppressWarnings("resource")
+		ExecutorService threads = Executors.newFixedThreadPool(THREAD_COUNT);
 
-			AudioVolumeManager audioVolumeManager = new AudioVolumeManager()
-					.registerManager(VolumeControl.MASTERVOLUME, musicManager)
-					.registerManager(VolumeControl.MASTERVOLUME, soundEffectManager)
-					.registerManager(VolumeControl.FX, soundEffectManager)
-					.registerManager(VolumeControl.MUSIC, musicManager);
+		try {
 
-			new AudioEventListener<>(
-					musicManager,
-					soundEffectManager,
-					audioVolumeManager
-			).initListeners("medium-button-click.wav");
+			threads.submit(() -> {
+				new NetworkingClientEventListener(
+						GlobalEventBus.get(),
+						new NetworkingClientManager(GlobalEventBus.get()));
 
-		}).start();
+				latch.countDown();
+			});
 
-		// Threads must be ready, before continue, TODO use latch instead
-        try {
-            Thread.sleep(200);
-        } catch (InterruptedException e) {
-            throw new RuntimeException(e);
-        }
-    }
+			threads.submit(() -> {
+				MusicManager<MusicAsset> musicManager =
+						new MusicManager<>(
+								GlobalEventBus.get(),
+								ResourceManager.getAllOfTypeAndRemoveWrapper(MusicAsset.class),
+								true
+						);
 
-	public static void startQuit() {
-		if (isQuitting) {
-			return;
+				SoundEffectManager<SoundEffectAsset> soundEffectManager =
+						new SoundEffectManager<>(ResourceManager.getAllOfType(SoundEffectAsset.class));
+
+				AudioVolumeManager audioVolumeManager = new AudioVolumeManager()
+						.registerManager(VolumeControl.MASTERVOLUME, musicManager)
+						.registerManager(VolumeControl.MASTERVOLUME, soundEffectManager)
+						.registerManager(VolumeControl.FX, soundEffectManager)
+						.registerManager(VolumeControl.MUSIC, musicManager);
+
+				new AudioEventListener<>(
+						GlobalEventBus.get(),
+						musicManager,
+						soundEffectManager,
+						audioVolumeManager
+				).initListeners("medium-button-click.wav");
+
+				latch.countDown();
+			});
+
+		} finally {
+			latch.await();
+			threads.shutdown();
 		}
-
-		WidgetContainer.add(Pos.CENTER, new QuitPopup());
-		isQuitting = true;
-	}
-
-	public static void stopQuit() {
-		isQuitting = false;
-	}
+    }
 
 	public static void quit() {
 		stage.close();

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

@@ -2,9 +2,7 @@ package org.toop.app;
 
 import javafx.application.Platform;
 import javafx.geometry.Pos;
-import org.toop.app.gameControllers.AbstractGameController;
-import org.toop.app.gameControllers.ReversiController;
-import org.toop.app.gameControllers.TicTacToeController;
+import org.toop.app.gameControllers.*;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.complex.LoadingWidget;
@@ -13,17 +11,19 @@ import org.toop.app.widget.popup.ErrorPopup;
 import org.toop.app.widget.popup.SendChallengePopup;
 import org.toop.app.widget.view.ServerView;
 import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.game.players.ArtificialPlayer;
+import org.toop.framework.game.players.OnlinePlayer;
+import org.toop.framework.gameFramework.controller.GameController;
+import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.framework.networking.clients.TournamentNetworkingClient;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.framework.networking.types.NetworkingConnector;
-import org.toop.game.players.ArtificialPlayer;
-import org.toop.game.players.OnlinePlayer;
-import org.toop.game.games.reversi.ReversiAIR;
-import org.toop.game.games.reversi.ReversiR;
-import org.toop.game.games.tictactoe.TicTacToeAIR;
+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.game.players.ai.mcts.MCTSAI3;
 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 +32,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;
 
@@ -42,13 +43,13 @@ public final class Server {
 	private ServerView primary;
 	private boolean isPolling = true;
 
-    private AbstractGameController<?> gameController;
+    private GameController gameController;
 
     private final AtomicBoolean isSingleGame = new AtomicBoolean(false);
 
 	private ScheduledExecutorService scheduler;
 
-    private EventFlow eventFlow = new EventFlow();
+	private EventFlow connectFlow;
 
 	public static GameInformation.Type gameToType(String game) {
 		if (game.equalsIgnoreCase("tic-tac-toe")) {
@@ -60,10 +61,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,84 +87,96 @@ public final class Server {
 			return;
 		}
 
+		this.nettyGatewayServer = nettyGatewayServer;
+
 		final int reconnectAttempts = 10;
 
 		LoadingWidget loading = new LoadingWidget(
                 Primitive.text("connecting"), 0, 0, reconnectAttempts, true, true
         );
 
-		WidgetContainer.getCurrentView().transitionNext(loading);
+		WidgetContainer.getCurrentView().transitionNextCustom(loading, "disconnect", this::disconnect);
 
 		var a = new EventFlow()
 			.addPostEvent(NetworkEvents.StartClient.class,
-				new TournamentNetworkingClient(),
+				new TournamentNetworkingClient(GlobalEventBus.get()),
 				new NetworkingConnector(ip, parsedPort, reconnectAttempts, 1, TimeUnit.SECONDS)
 			);
 
         loading.setOnFailure(() -> {
-            WidgetContainer.getCurrentView().transitionPrevious();
-            a.unsubscribe("connecting");
-			a.unsubscribe("startclient");
+            if (WidgetContainer.getCurrentView() == loading) WidgetContainer.getCurrentView().transitionPrevious();
+			a.unsubscribeAll();
             WidgetContainer.add(
                     Pos.CENTER,
                     new ErrorPopup(AppContext.getString("connecting-failed") + " " + ip + ":" + port)
             );
         });
 
-		a.onResponse(NetworkEvents.StartClientResponse.class, e -> {
+		a.onResponse(NetworkEvents.CreatedIdForClient.class, e -> clientId = e.clientId(), true);
 
+		a.onResponse(NetworkEvents.StartClientResponse.class, e -> {
 			if (!e.successful()) {
 				return;
 			}
 
-			WidgetContainer.getCurrentView().transitionPrevious();
+			primary = new ServerView(user, this::sendChallenge, user, clientId);
+
+			WidgetContainer.getCurrentView().transitionNextCustom(primary, "disconnect", this::disconnect);
 
 			a.unsubscribe("connecting");
 			a.unsubscribe("startclient");
 
 			this.user = user;
-			clientId = e.clientId();
 
 			new EventFlow().addPostEvent(new NetworkEvents.SendLogin(clientId, user)).postEvent();
 
-			primary = new ServerView(user, this::sendChallenge, this::disconnect);
-			WidgetContainer.getCurrentView().transitionNext(primary);
-
 			startPopulateScheduler();
 			populateGameList();
+
+			primary.removeViewFromPreviousChain(loading);
+
 		}, false, "startclient")
 				.listen(
-                        NetworkEvents.ConnectTry.class,
-                        e -> Platform.runLater(
-                                () -> {
-                                    try {
-                                        loading.setAmount(e.amount());
-                                        if (e.amount() >= loading.getMaxAmount()) {
-                                            loading.triggerFailure();
-                                        }
-                                    } catch (Exception ex) {
-                                        throw new RuntimeException(ex);
-                                    }
-                                }
-                        ),
-                        false, "connecting"
-                )
+						NetworkEvents.ConnectTry.class,
+						e -> {
+							if (clientId != e.clientId()) return;
+							Platform.runLater(
+									() -> {
+										try {
+											loading.setAmount(e.amount());
+											if (e.amount() >= loading.getMaxAmount()) {
+												loading.triggerFailure();
+											}
+										} catch (Exception ex) {
+											throw new RuntimeException(ex);
+										}
+									}
+							);
+						},
+						false, "connecting"
+				)
 				.postEvent();
 
-		eventFlow.listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false)
-                .listen(NetworkEvents.GameMatchResponse.class, this::handleMatchResponse, false)
-                .listen(NetworkEvents.GameResultResponse.class, this::handleGameResult, false)
-                .listen(NetworkEvents.GameMoveResponse.class, this::handleReceivedMove, false)
-                .listen(NetworkEvents.YourTurnResponse.class, this::handleYourTurn, false);
+		a.listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false, "challenge")
+                .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.ClosedConnection.class, this::closedConnection, false, "closed-connection")
+                .listen(NetworkEvents.TournamentResultResponse.class, this::handleTournamentResult, false, "tournament-result");
+
+		connectFlow = a;
 	}
 
 	private void sendChallenge(String opponent) {
 		if (!isPolling) return;
 
-		new SendChallengePopup(this, opponent, (playerInformation, gameType) -> {
+		var a = new SendChallengePopup(this, opponent, (playerInformation, gameType) -> {
 			new EventFlow().addPostEvent(new NetworkEvents.SendChallenge(clientId, opponent, gameType)).postEvent();
             isSingleGame.set(true);
 		});
+
+		a.show(Pos.CENTER);
 	}
 
     private void handleMatchResponse(NetworkEvents.GameMatchResponse response) {
@@ -171,7 +187,7 @@ public final class Server {
 
         gameController = null;
 
-        //if (!isPolling) return;
+//        if (!isPolling) return;
 
         String gameType = extractQuotedValue(response.gameType());
         if (response.clientId() == clientId) {
@@ -184,40 +200,30 @@ 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();
+            information.players[userStartingTurn].name = user;
+            information.players[opponentStartingTurn].name = response.opponent();
 
             Player[] players = new Player[2];
 
-            players[(myTurn + 1) % 2] = new OnlinePlayer<ReversiR>(response.opponent());
-
-            switch (type){
-                case TICTACTOE ->{
-                    players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(), user);
-                }
-                case REVERSI ->{
-                    players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
-                }
-            }
+            players[userStartingTurn] = new ArtificialPlayer(new MCTSAI3(1000, Runtime.getRuntime().availableProcessors()), user);
+            players[opponentStartingTurn] = new OnlinePlayer(response.opponent());
 
             switch (type) {
-                case TICTACTOE ->{
-                        gameController = new TicTacToeController(players, false);
-                }
-                case REVERSI ->
-                        gameController = new ReversiController(players, false);
+                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
             }
         }
     }
@@ -237,6 +243,13 @@ public final class Server {
         gameController.gameFinished(response);
     }
 
+    private void handleTournamentResult(NetworkEvents.TournamentResultResponse response) {
+        IO.println(response.gameType());
+        IO.println(Arrays.toString(response.names()));
+		IO.println(Arrays.toString(response.scoreTypes()));
+        IO.println(Arrays.toString(response.scores().toArray()));
+    }
+
     private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
         if (gameController == null) {
             return;
@@ -250,11 +263,13 @@ public final class Server {
 		String challengerName = extractQuotedValue(response.challengerName());
 		String gameType = extractQuotedValue(response.gameType());
 		final String finalGameType = gameType;
-		new ChallengePopup(challengerName, gameType, (playerInformation) -> {
-			final int challengeId = Integer.parseInt(response.challengeId().replaceAll("\\D", ""));
+		var a = new ChallengePopup(challengerName, gameType, (playerInformation) -> {
+			final long challengeId = Long.parseLong(response.challengeId().replaceAll("\\D", ""));
 			new EventFlow().addPostEvent(new NetworkEvents.SendAcceptChallenge(clientId, challengeId)).postEvent();
             isSingleGame.set(true);
 		});
+
+		a.show(Pos.CENTER);
 	}
 
 	private void sendMessage(String message) {
@@ -265,7 +280,27 @@ public final class Server {
 		new EventFlow().addPostEvent(new NetworkEvents.CloseClient(clientId)).postEvent();
 		isPolling = false;
 		stopScheduler();
-		primary.transitionPrevious();
+		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() {
@@ -314,7 +349,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

@@ -0,0 +1,245 @@
+package org.toop.app.canvas;
+
+import javafx.animation.KeyFrame;
+import javafx.animation.Timeline;
+import javafx.scene.canvas.Canvas;
+import javafx.scene.canvas.GraphicsContext;
+import javafx.scene.input.MouseButton;
+import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
+import javafx.util.Duration;
+import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.view.GUIEvents;
+
+import java.util.function.Consumer;
+
+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 &&
+				y >= this.y && y <= this.y + height;
+		}
+	}
+
+	protected final Canvas canvas;
+	protected final GraphicsContext graphics;
+
+	protected final Color color;
+	protected final Color backgroundColor;
+
+	protected final int width;
+	protected final int height;
+
+	protected final int rowSize;
+	protected final int columnSize;
+
+	protected final int gapSize;
+	protected final boolean edges;
+
+	protected final Cell[] cells;
+
+    private Consumer<Long> onCellCLicked;
+
+    public void setOnCellClicked(Consumer<Long> onClick) {
+        this.onCellCLicked = onClick;
+    }
+
+	protected BitGameCanvas(Color color, Color backgroundColor, int width, int height, int rowSize, int columnSize, int gapSize, boolean edges) {
+		canvas = new Canvas(width, height);
+		graphics = canvas.getGraphicsContext2D();
+
+        this.onCellCLicked = (c) -> new EventFlow().addPostEvent(GUIEvents.PlayerAttemptedMove.class, c).postEvent();
+
+		this.color = color;
+		this.backgroundColor = backgroundColor;
+
+		this.width = width;
+		this.height = height;
+
+		this.rowSize = rowSize;
+		this.columnSize = columnSize;
+
+		this.gapSize = gapSize;
+		this.edges = edges;
+
+		cells = new Cell[rowSize * columnSize];
+
+		final float cellWidth = ((float) width - gapSize * rowSize - gapSize) / rowSize;
+		final float cellHeight = ((float) height - gapSize * columnSize - gapSize) / columnSize;
+
+		for (int y = 0; y < columnSize; y++) {
+			final float startY = y * cellHeight + y * gapSize + gapSize;
+
+			for (int x = 0; x < rowSize; x++) {
+				final float startX = x * cellWidth + x * gapSize + gapSize;
+				cells[x + y * rowSize] = new Cell(startX, startY, cellWidth, cellHeight);
+			}
+		}
+
+		canvas.setOnMouseClicked(event -> {
+
+			if (event.getButton() != MouseButton.PRIMARY) {
+				return;
+			}
+
+			final int column = (int) ((event.getX() / this.width) * rowSize);
+			final int row = (int) ((event.getY() / this.height) * columnSize);
+
+			final Cell cell = cells[column + row * rowSize];
+
+			if (cell.isInside(event.getX(), event.getY())) {
+				event.consume();
+				this.onCellCLicked.accept(1L << (column + row * rowSize));
+			}
+		});
+
+		render();
+	}
+
+    public void loopOverBoard(long bb, Consumer<Integer> onCell){
+        while (bb != 0) {
+            int idx = Long.numberOfTrailingZeros(bb); // index of least-significant 1-bit
+            onCell.accept(idx);
+
+            bb &= bb - 1; // clear LSB 1-bit
+        }
+    }
+
+	private void render() {
+		graphics.setFill(backgroundColor);
+		graphics.fillRect(0, 0, width, height);
+
+		graphics.setFill(color);
+
+		for (int x = 0; x < rowSize - 1; x++) {
+			final float start = cells[x].x + cells[x].width;
+			graphics.fillRect(start, gapSize, gapSize, height - gapSize * 2);
+		}
+
+		for (int y = 0; y < columnSize - 1; y++) {
+			final float start = cells[y * rowSize].y + cells[y * rowSize].height;
+			graphics.fillRect(gapSize, start, width - gapSize * 2, gapSize);
+		}
+
+		if (edges) {
+			graphics.fillRect(0, 0, width, gapSize);
+			graphics.fillRect(0, 0, gapSize, height);
+
+			graphics.fillRect(width - gapSize, 0, gapSize, height);
+			graphics.fillRect(0, height - gapSize, width, gapSize);
+		}
+	}
+
+	public void fill(Color color, int cell) {
+		final float x = cells[cell].x();
+		final float y = cells[cell].y();
+
+		final float width = cells[cell].width();
+		final float height = cells[cell].height();
+
+		graphics.setFill(color);
+		graphics.fillRect(x, y, width, height);
+	}
+
+	public void clear(int cell) {
+		final float x = cells[cell].x();
+		final float y = cells[cell].y();
+
+		final float width = cells[cell].width();
+		final float height = cells[cell].height();
+
+		graphics.clearRect(x, y, width, height);
+
+		graphics.setFill(backgroundColor);
+		graphics.fillRect(x, y, width, height);
+	}
+
+	public void clearAll() {
+		for (int i = 0; i < cells.length; i++) {
+			clear(i);
+		}
+	}
+
+    public void drawPlayerMove(int player, int move) {
+        final float x = cells[move].x() + gapSize;
+        final float y = cells[move].y() + gapSize;
+
+        final float width = cells[move].width() - gapSize * 2;
+        final float height = cells[move].height() - gapSize * 2;
+
+        graphics.setFill(color);
+        graphics.setFont(Font.font("Arial", 40)); // TODO different font and size
+        graphics.fillText(String.valueOf(player), x + width, y + height);
+    }
+
+	public void drawDot(Color color, int cell) {
+		final float x = cells[cell].x() + gapSize;
+		final float y = cells[cell].y() + gapSize;
+
+		final float width = cells[cell].width() - gapSize * 2;
+		final float height = cells[cell].height() - gapSize * 2;
+
+		graphics.setFill(color);
+		graphics.fillOval(x, y, width, height);
+	}
+
+    public void drawInnerDot(Color color, int cell, boolean slightlyBigger) {
+        final float x = cells[cell].x() + gapSize;
+        final float y = cells[cell].y() + gapSize;
+
+        float multiplier = slightlyBigger?1.4f:1.5f;
+
+        final float width = (cells[cell].width() - gapSize * 2)/multiplier;
+        final float height = (cells[cell].height() - gapSize * 2)/multiplier;
+
+        float offset = slightlyBigger?5f:4f;
+
+        graphics.setFill(color);
+        graphics.fillOval(x + width/offset, y + height/offset, width, height);
+    }
+
+	private void drawDotScaled(Color color, int cell, double scale) {
+		final float cx = cells[cell].x() + gapSize;
+		final float cy = cells[cell].y() + gapSize;
+
+		final float fullWidth = cells[cell].width() - gapSize * 2;
+		final float height = cells[cell].height() - gapSize * 2;
+
+		final float scaledWidth = (float)(fullWidth * scale);
+		final float offsetX = (fullWidth - scaledWidth) / 2;
+
+		graphics.setFill(color);
+		graphics.fillOval(cx + offsetX, cy, scaledWidth, height);
+	}
+
+	public Timeline flipDot(Color fromColor, Color toColor, int cell) {
+		final int steps = 60;
+		final long duration = 250;
+		final double interval = duration / (double) steps;
+
+		final Timeline timeline = new Timeline();
+
+		for (int i = 0; i <= steps; i++) {
+			final double t = i / (double) steps;
+			final KeyFrame keyFrame = new KeyFrame(Duration.millis(i * interval),
+				_ -> {
+					clear(cell);
+
+					final double scale = t <= 0.5 ? 1 - 2 * t : 2 * t - 1;
+					final Color currentColor = t < 0.5 ? fromColor : toColor;
+
+					drawDotScaled(currentColor, cell, scale);
+				}
+			);
+
+			timeline.getKeyFrames().add(keyFrame);
+		}
+
+		return timeline;
+	}
+
+	public Canvas getCanvas() {
+		return canvas;
+	}
+}

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

@@ -1,17 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-
-import java.util.function.Consumer;
-
-public class Connect4Canvas extends GameCanvas {
-    public Connect4Canvas(Color color, int width, int height, Consumer<Integer> onCellClicked) {
-        super(color, Color.TRANSPARENT, width, height, 7, 6, 10, true, onCellClicked,null);
-    }
-
-    @Override
-    public void drawPlayerHover(int player, int move, AbstractGame game) {
-
-    }
-}

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

@@ -1,7 +1,7 @@
 package org.toop.app.canvas;
 
-import org.toop.framework.gameFramework.model.game.AbstractGame;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 public interface DrawPlayerHover {
-    void drawPlayerHover(int player, int move, AbstractGame game);
+    void drawPlayerHover(int player, int move, TurnBasedGame game);
 }

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

@@ -1,237 +1,9 @@
 package org.toop.app.canvas;
 
-import javafx.animation.KeyFrame;
-import javafx.animation.Timeline;
 import javafx.scene.canvas.Canvas;
-import javafx.scene.canvas.GraphicsContext;
-import javafx.scene.input.MouseButton;
-import javafx.scene.paint.Color;
-import javafx.scene.text.Font;
-import javafx.util.Duration;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-import java.util.function.Consumer;
-
-public abstract class GameCanvas<T extends AbstractGame> implements DrawPlayerMove, DrawPlayerHover {
-	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 &&
-				y >= this.y && y <= this.y + height;
-		}
-	}
-
-	protected final Canvas canvas;
-	protected final GraphicsContext graphics;
-
-	protected final Color color;
-	protected final Color backgroundColor;
-
-	protected final int width;
-	protected final int height;
-
-	protected final int rowSize;
-	protected final int columnSize;
-
-	protected final int gapSize;
-	protected final boolean edges;
-
-	protected final Cell[] cells;
-
-    private Consumer<Integer> onCellCLicked;
-
-    public void setOnCellClicked(Consumer<Integer> onClick) {
-        this.onCellCLicked = onClick;
-    }
-
-	protected GameCanvas(Color color, Color backgroundColor, int width, int height, int rowSize, int columnSize, int gapSize, boolean edges, Consumer<Integer> onCellClicked, Consumer<Integer> newCellEntered) {
-		canvas = new Canvas(width, height);
-		graphics = canvas.getGraphicsContext2D();
-
-        this.onCellCLicked = onCellClicked;
-
-		this.color = color;
-		this.backgroundColor = backgroundColor;
-
-		this.width = width;
-		this.height = height;
-
-		this.rowSize = rowSize;
-		this.columnSize = columnSize;
-
-		this.gapSize = gapSize;
-		this.edges = edges;
-
-		cells = new Cell[rowSize * columnSize];
-
-		final float cellWidth = ((float) width - gapSize * rowSize - gapSize) / rowSize;
-		final float cellHeight = ((float) height - gapSize * columnSize - gapSize) / columnSize;
-
-		for (int y = 0; y < columnSize; y++) {
-			final float startY = y * cellHeight + y * gapSize + gapSize;
-
-			for (int x = 0; x < rowSize; x++) {
-				final float startX = x * cellWidth + x * gapSize + gapSize;
-				cells[x + y * rowSize] = new Cell(startX, startY, cellWidth, cellHeight);
-			}
-		}
-
-		canvas.setOnMouseClicked(event -> {
-			if (event.getButton() != MouseButton.PRIMARY) {
-				return;
-			}
-
-			final int column = (int) ((event.getX() / this.width) * rowSize);
-			final int row = (int) ((event.getY() / this.height) * columnSize);
-
-			final Cell cell = cells[column + row * rowSize];
-
-			if (cell.isInside(event.getX(), event.getY())) {
-				event.consume();
-				this.onCellCLicked.accept(column + row * rowSize);
-			}
-		});
-
-
-
-
-		render();
-	}
-
-	private void render() {
-		graphics.setFill(backgroundColor);
-		graphics.fillRect(0, 0, width, height);
-
-		graphics.setFill(color);
-
-		for (int x = 0; x < rowSize - 1; x++) {
-			final float start = cells[x].x + cells[x].width;
-			graphics.fillRect(start, gapSize, gapSize, height - gapSize * 2);
-		}
-
-		for (int y = 0; y < columnSize - 1; y++) {
-			final float start = cells[y * rowSize].y + cells[y * rowSize].height;
-			graphics.fillRect(gapSize, start, width - gapSize * 2, gapSize);
-		}
-
-		if (edges) {
-			graphics.fillRect(0, 0, width, gapSize);
-			graphics.fillRect(0, 0, gapSize, height);
-
-			graphics.fillRect(width - gapSize, 0, gapSize, height);
-			graphics.fillRect(0, height - gapSize, width, gapSize);
-		}
-	}
-
-	public void fill(Color color, int cell) {
-		final float x = cells[cell].x();
-		final float y = cells[cell].y();
-
-		final float width = cells[cell].width();
-		final float height = cells[cell].height();
-
-		graphics.setFill(color);
-		graphics.fillRect(x, y, width, height);
-	}
-
-	public void clear(int cell) {
-		final float x = cells[cell].x();
-		final float y = cells[cell].y();
-
-		final float width = cells[cell].width();
-		final float height = cells[cell].height();
-
-		graphics.clearRect(x, y, width, height);
-
-		graphics.setFill(backgroundColor);
-		graphics.fillRect(x, y, width, height);
-	}
-
-	public void clearAll() {
-		for (int i = 0; i < cells.length; i++) {
-			clear(i);
-		}
-	}
-
-    @Override
-    public void drawPlayerMove(int player, int move) {
-        final float x = cells[move].x() + gapSize;
-        final float y = cells[move].y() + gapSize;
-
-        final float width = cells[move].width() - gapSize * 2;
-        final float height = cells[move].height() - gapSize * 2;
-
-        graphics.setFill(color);
-        graphics.setFont(Font.font("Arial", 40)); // TODO different font and size
-        graphics.fillText(String.valueOf(player), x + width, y + height);
-    }
-
-	public void drawDot(Color color, int cell) {
-		final float x = cells[cell].x() + gapSize;
-		final float y = cells[cell].y() + gapSize;
-
-		final float width = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		graphics.setFill(color);
-		graphics.fillOval(x, y, width, height);
-	}
-
-    public void drawInnerDot(Color color, int cell, boolean slightlyBigger) {
-        final float x = cells[cell].x() + gapSize;
-        final float y = cells[cell].y() + gapSize;
-
-        float multiplier = slightlyBigger?1.4f:1.5f;
-
-        final float width = (cells[cell].width() - gapSize * 2)/multiplier;
-        final float height = (cells[cell].height() - gapSize * 2)/multiplier;
-
-        float offset = slightlyBigger?5f:4f;
-
-        graphics.setFill(color);
-        graphics.fillOval(x + width/offset, y + height/offset, width, height);
-    }
-
-	private void drawDotScaled(Color color, int cell, double scale) {
-		final float cx = cells[cell].x() + gapSize;
-		final float cy = cells[cell].y() + gapSize;
-
-		final float fullWidth = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		final float scaledWidth = (float)(fullWidth * scale);
-		final float offsetX = (fullWidth - scaledWidth) / 2;
-
-		graphics.setFill(color);
-		graphics.fillOval(cx + offsetX, cy, scaledWidth, height);
-	}
-
-	public Timeline flipDot(Color fromColor, Color toColor, int cell) {
-		final int steps = 60;
-		final long duration = 250;
-		final double interval = duration / (double) steps;
-
-		final Timeline timeline = new Timeline();
-
-		for (int i = 0; i <= steps; i++) {
-			final double t = i / (double) steps;
-			final KeyFrame keyFrame = new KeyFrame(Duration.millis(i * interval),
-				_ -> {
-					clear(cell);
-
-					final double scale = t <= 0.5 ? 1 - 2 * t : 2 * t - 1;
-					final Color currentColor = t < 0.5 ? fromColor : toColor;
-
-					drawDotScaled(currentColor, cell, scale);
-				}
-			);
-
-			timeline.getKeyFrames().add(keyFrame);
-		}
-
-		return timeline;
-	}
-
-	public Canvas getCanvas() {
-		return canvas;
-	}
-}
+public interface GameCanvas {
+    Canvas getCanvas();
+    void redraw(TurnBasedGame gameCopy);
+}

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

@@ -0,0 +1,68 @@
+package org.toop.app.canvas;
+
+import javafx.scene.paint.Color;
+import org.toop.app.App;
+import org.toop.framework.game.games.reversi.BitboardReversi;
+import org.toop.framework.game.players.LocalPlayer;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+public class ReversiBitCanvas extends BitGameCanvas {
+    private TurnBasedGame gameCopy;
+    private int previousCell;
+    public ReversiBitCanvas() {
+        super(Color.GRAY, new Color(0f, 0.4f, 0.2f, 1f), (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3, 8, 8, 5, true);
+        canvas.setOnMouseMoved(event -> {
+            double mouseX = event.getX();
+            double mouseY = event.getY();
+            int cellId = -1;
+
+            BitGameCanvas.Cell hovered = null;
+            for (BitGameCanvas.Cell cell : cells) {
+                if (cell.isInside(mouseX, mouseY)) {
+                    hovered = cell;
+                    cellId = turnCoordsIntoCellId(mouseX, mouseY);
+                    break;
+                }
+            }
+            if (hovered != null) {
+                checkHoverDots(hovered, cellId);
+            }
+        });
+    }
+
+    private int turnCoordsIntoCellId(double x, double y) {
+        final int column = (int) ((x / this.width) * rowSize);
+        final int row = (int) ((y / this.height) * columnSize);
+        return column + row * rowSize;
+    }
+
+    @Override
+    public void redraw(TurnBasedGame gameCopy) {
+        this.gameCopy = gameCopy;
+        clearAll();
+        long[] board = gameCopy.getBoard();
+        loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
+        loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
+    }
+
+    public void drawLegalDots(TurnBasedGame gameCopy){
+        long legal = gameCopy.getLegalMoves();
+        loopOverBoard(legal, (i) -> drawInnerDot(gameCopy.getCurrentTurn()==0?new Color(1f,1f,1f,0.65f) :new Color(0f,0f,0f,0.65f), i,false));
+    }
+
+    private void checkHoverDots(BitGameCanvas.Cell hovered, int cellId){
+        if (previousCell == cellId){
+            return;
+        }
+        long backflips = ((BitboardReversi)gameCopy).getFlips(1L << previousCell);
+        loopOverBoard(backflips, (i) -> drawInnerDot(gameCopy.getCurrentTurn()==1?Color.WHITE:Color.BLACK, i,true));
+        previousCell = cellId;
+        if (gameCopy.getPlayer(gameCopy.getCurrentTurn()) instanceof LocalPlayer) {
+            long legal = gameCopy.getLegalMoves();
+            if ((legal & (1L << cellId)) != 0) {
+                long flips = ((BitboardReversi) gameCopy).getFlips(1L << cellId);
+                loopOverBoard(flips, (i) -> drawInnerDot(gameCopy.getCurrentTurn() == 0 ? Color.WHITE : Color.BLACK, i, false));
+            }
+        }
+    }
+}

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

@@ -1,96 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-import org.toop.game.Move;
-import org.toop.game.games.reversi.ReversiR;
-
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.function.Consumer;
-
-public final class ReversiCanvas extends GameCanvas<ReversiR> {
-    private Move[] currentlyHighlightedMoves = null;
-	public ReversiCanvas(Color color, int width, int height, Consumer<Integer> onCellClicked,  Consumer<Integer> newCellEntered) {
-		super(color, new Color(0f,0.4f,0.2f,1f), width, height, 8, 8, 5, true, onCellClicked,  newCellEntered);
-		drawStartingDots();
-
-        final AtomicReference<Cell> lastHoveredCell = new AtomicReference<>(null);
-
-        canvas.setOnMouseMoved(event -> {
-            double mouseX = event.getX();
-            double mouseY = event.getY();
-            int cellId = -1;
-
-            Cell hovered = null;
-            for (Cell cell : cells) {
-                if (cell.isInside(mouseX, mouseY)) {
-                    hovered = cell;
-                    cellId = turnCoordsIntoCellId(mouseX, mouseY);
-                    break;
-                }
-            }
-
-            Cell previous = lastHoveredCell.get();
-
-            if (hovered != previous) {
-                lastHoveredCell.set(hovered);
-                newCellEntered.accept(cellId);
-            }
-        });
-	}
-
-    public void setCurrentlyHighlightedMovesNull() {
-        currentlyHighlightedMoves = null;
-    }
-
-    public void drawHighlightDots(Move[] moves){
-        if (currentlyHighlightedMoves != null){
-            for (final Move move : currentlyHighlightedMoves){
-                Color color = move.value() == 'W'? Color.BLACK: Color.WHITE;
-                drawInnerDot(color, move.position(), true);
-            }
-        }
-        currentlyHighlightedMoves = moves;
-        if (moves != null) {
-            for (Move move : moves) {
-                Color color = move.value() == 'B' ? Color.BLACK : Color.WHITE;
-                drawInnerDot(color, move.position(), false);
-            }
-        }
-    }
-
-    private int turnCoordsIntoCellId(double x, double y) {
-        final int column = (int) ((x / this.width) * rowSize);
-        final int row = (int) ((y / this.height) * columnSize);
-        return column + row * rowSize;
-    }
-
-	public void drawStartingDots() {
-		drawDot(Color.BLACK, 28);
-		drawDot(Color.WHITE, 36);
-		drawDot(Color.BLACK, 35);
-		drawDot(Color.WHITE, 27);
-	}
-
-	public void drawLegalPosition(int cell, char player) {
-
-        Color innerColor;
-        if (player == 'B') {
-            innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
-        }
-        else {
-            innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
-        }
-        drawInnerDot(innerColor, cell,false);
-	}
-
-    @Override
-    public void drawPlayerMove(int player ,int move){
-        super.drawPlayerMove(player, move);
-    }
-
-    @Override
-    public void drawPlayerHover(int player, int move, AbstractGame game) {
-
-    }
-}

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

@@ -0,0 +1,60 @@
+package org.toop.app.canvas;
+
+import javafx.scene.paint.Color;
+import org.toop.app.App;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+public class TicTacToeBitCanvas extends BitGameCanvas{
+    public TicTacToeBitCanvas() {
+        super(
+                Color.GRAY,
+                Color.TRANSPARENT,
+                (App.getHeight() / 4) * 3,
+                (App.getHeight() / 4) * 3,
+                3,
+                3,
+                30,
+                false
+        );
+    }
+
+    @Override
+    public void redraw(TurnBasedGame gameCopy) {
+        clearAll();
+        drawMoves(gameCopy.getBoard());
+    }
+
+    private void drawMoves(long[] gameBoard){
+        loopOverBoard(gameBoard[0], (i) -> drawX(Color.RED, i));
+        loopOverBoard(gameBoard[1], (i) -> drawO(Color.BLUE, i));
+
+    }
+
+
+    public void drawX(Color color, int cell) {
+        graphics.setStroke(color);
+        graphics.setLineWidth(gapSize);
+
+        final float x = cells[cell].x() + gapSize;
+        final float y = cells[cell].y() + gapSize;
+
+        final float width = cells[cell].width() - gapSize * 2;
+        final float height = cells[cell].height() - gapSize * 2;
+
+        graphics.strokeLine(x, y, x + width, y + height);
+        graphics.strokeLine(x + width, y, x, y + height);
+    }
+
+    public void drawO(Color color, int cell) {
+        graphics.setStroke(color);
+        graphics.setLineWidth(gapSize);
+
+        final float x = cells[cell].x() + gapSize;
+        final float y = cells[cell].y() + gapSize;
+
+        final float width = cells[cell].width() - gapSize * 2;
+        final float height = cells[cell].height() - gapSize * 2;
+
+        graphics.strokeOval(x, y, width, height);
+    }
+}

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

@@ -1,54 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-import org.toop.game.games.tictactoe.TicTacToeR;
-
-import java.util.function.Consumer;
-
-public final class TicTacToeCanvas extends GameCanvas<TicTacToeR> {
-	public TicTacToeCanvas(Color color, int width, int height, Consumer<Integer> onCellClicked) {
-		super(color, Color.TRANSPARENT, width, height, 3, 3, 30, false, onCellClicked,null);
-	}
-
-    @Override
-    public void drawPlayerMove(int player, int move) {
-        switch (player) {
-            case 0 -> drawX(Color.RED, move);
-            case 1 -> drawO(Color.BLUE, move);
-            default -> super.drawPlayerMove(player, move);
-        }
-    }
-
-	public void drawX(Color color, int cell) {
-		graphics.setStroke(color);
-		graphics.setLineWidth(gapSize);
-
-		final float x = cells[cell].x() + gapSize;
-		final float y = cells[cell].y() + gapSize;
-
-		final float width = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		graphics.strokeLine(x, y, x + width, y + height);
-		graphics.strokeLine(x + width, y, x, y + height);
-	}
-
-	public void drawO(Color color, int cell) {
-		graphics.setStroke(color);
-		graphics.setLineWidth(gapSize);
-
-		final float x = cells[cell].x() + gapSize;
-		final float y = cells[cell].y() + gapSize;
-
-		final float width = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		graphics.strokeOval(x, y, width, height);
-	}
-
-    @Override
-    public void drawPlayerHover(int player, int move, AbstractGame game) {
-
-    }
-}

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

@@ -1,127 +0,0 @@
-package org.toop.app.gameControllers;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.toop.framework.gameFramework.controller.UpdatesGameUI;
-import org.toop.framework.gameFramework.view.GUIEvents;
-import org.toop.app.canvas.GameCanvas;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
-import org.toop.app.widget.view.GameView;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
-import org.toop.framework.gameFramework.model.player.Player;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-
-public abstract class AbstractGameController<T extends AbstractGame<T>> implements UpdatesGameUI, ThreadBehaviour<T> {
-    protected final EventFlow eventFlow = new EventFlow();
-
-    protected final List<Consumer<?>> listeners = new ArrayList<>();
-
-    // Logger for logging ofcourse
-    protected final Logger logger = LogManager.getLogger(this.getClass());
-
-    // Reference to primary view
-    protected final GameView primary;
-
-    // Reference to game canvas
-    protected final GameCanvas<T> canvas;
-
-    private final Player<T>[] players;         // List of players, can't be changed.
-    protected final T game;       // Reference to game instance
-    private final ThreadBehaviour<T> gameThreadBehaviour;
-
-    // TODO: Change gameType to automatically happen with either dependency injection or something else.
-    // TODO: Make visualisation of moves a behaviour.
-    protected AbstractGameController(GameCanvas<T> canvas, Player<T>[] players, T game, ThreadBehaviour<T> gameThreadBehaviour, String gameType) {
-        logger.info("Creating AbstractGameController");
-        // Make sure player list matches expected size
-        if (players.length != game.getPlayerCount()){
-            logger.error("Player count mismatch");
-            throw new IllegalArgumentException("players and game's players must have same length");
-        }
-
-        this.canvas = canvas;
-        this.players = players;
-        this.game = game;
-        this.gameThreadBehaviour = gameThreadBehaviour;
-
-        primary = new GameView(null, null, null, gameType);
-        addListeners();
-    }
-
-    public void start(){
-        logger.info("Starting GameManager");
-        gameThreadBehaviour.start();;
-    }
-
-    public void stop(){
-        logger.info("Stopping GameManager");
-        removeListeners();
-        gameThreadBehaviour.stop();
-    }
-
-    public Player<T> getCurrentPlayer(){
-        return game.getPlayer(getCurrentPlayerIndex());
-    };
-
-    public int getCurrentPlayerIndex(){
-        return game.getCurrentTurn();
-    }
-
-    private void addListeners(){
-        eventFlow
-                .listen(GUIEvents.RefreshGameCanvas.class, this::onUpdateGameUI, false)
-                .listen(GUIEvents.GameEnded.class, this::onGameFinish, false);
-    }
-
-    private void removeListeners(){
-        eventFlow.unsubscribeAll();
-    }
-
-    private void onUpdateGameUI(GUIEvents.RefreshGameCanvas event){
-        this.updateUI();
-    }
-
-    private void onGameFinish(GUIEvents.GameEnded event){
-        logger.info("Game Finished");
-        String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
-        primary.gameOver(event.winOrTie(), name);
-        stop();
-    }
-
-    public Player<T> getPlayer(int player){
-        if (player < 0 || player >= players.length){
-            logger.error("Invalid player index");
-            throw new IllegalArgumentException("player out of range");
-        }
-        return players[player];
-    }
-
-    private boolean isOnline(){
-        return this.gameThreadBehaviour instanceof SupportsOnlinePlay;
-    }
-
-    public void onYourTurn(NetworkEvents.YourTurnResponse event){
-        if (isOnline()){
-            ((OnlineThreadBehaviour<T>) this.gameThreadBehaviour).onYourTurn(event);
-        }
-    }
-
-    public void onMoveReceived(NetworkEvents.GameMoveResponse event){
-        if (isOnline()){
-            ((OnlineThreadBehaviour<T>) this.gameThreadBehaviour).onMoveReceived(event);
-        }
-    }
-
-    public void gameFinished(NetworkEvents.GameResultResponse event){
-        if (isOnline()){
-            ((OnlineThreadBehaviour<T>) this.gameThreadBehaviour).gameFinished(event);
-        }
-    }
-}

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

@@ -0,0 +1,165 @@
+package org.toop.app.gameControllers;
+
+import javafx.application.Platform;
+import javafx.geometry.Pos;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.app.canvas.GameCanvas;
+import org.toop.app.canvas.ReversiBitCanvas;
+import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.view.GameView;
+import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.framework.gameFramework.controller.GameController;
+import org.toop.framework.gameFramework.model.game.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.connection.events.NetworkEvents;
+import org.toop.framework.game.players.LocalPlayer;
+
+public class GenericGameController implements GameController {
+    protected final EventFlow eventFlow = new EventFlow();
+
+    // Logger for logging
+    protected final Logger logger = LogManager.getLogger(this.getClass());
+
+    // Reference to gameView view
+    protected final GameView gameView;
+
+    // Reference to game canvas
+    protected final GameCanvas canvas;
+
+    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 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)))
+        );
+
+        // Tell thread how to update UI
+        this.gameThreadBehaviour.setOnUpdateUI(() -> Platform.runLater(this::updateUI));
+
+        // Change scene to game view
+        gameView = new GameView(null, null, null, gameType);
+        gameView.add(Pos.CENTER, canvas.getCanvas());
+        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 -> {
+                    logger.info("User attempting move {}", event.move());
+                    logger.info("Current player's turn {}", getCurrentPlayer().getName());
+                    logger.info("First player {}", game.getPlayer(0).getName());
+                    logger.info("Username {}", getCurrentPlayer().getName());
+                    logger.info("User is class {}, {}", getCurrentPlayer().getClass(), getCurrentPlayer() instanceof LocalPlayer);
+                    if (getCurrentPlayer() instanceof LocalPlayer lp) {
+                        try {
+                            lp.setLastMove(event.move());
+                        } catch (Exception e) {
+                            IO.println(e);
+                        }
+                    }
+                }, false);
+    }
+
+    public void start(){
+        logger.info("Starting GameManager");
+        updateUI();
+        gameThreadBehaviour.start();
+        logger.info("GameManager started");
+    }
+
+    public void stop(){
+        logger.info("Stopping GameManager");
+        removeListeners();
+        gameThreadBehaviour.stop();
+        logger.info("GameManager stopped");
+    }
+
+    public Player getCurrentPlayer(){
+        return game.getPlayer(getCurrentPlayerIndex());
+    }
+
+    public int getCurrentPlayerIndex(){
+        return game.getCurrentTurn();
+    }
+
+    protected long translateMove(int move){
+        return 1L << move;
+    }
+
+    protected int translateMove(long move){
+        return Long.numberOfTrailingZeros(move);
+    }
+
+    private void removeListeners(){
+        eventFlow.unsubscribeAll();
+    }
+
+    private void onGameFinish(GUIEvents.GameEnded event){
+        logger.info("OnlineTurnBasedGame Finished");
+        String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
+        gameView.gameOver(event.winOrTie(), name);
+        stop();
+    }
+
+    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");
+        }
+        return game.getPlayer(player);
+    }
+
+    private boolean isOnline(){
+        return this.gameThreadBehaviour instanceof SupportsOnlinePlay;
+    }
+
+    public void onYourTurn(NetworkEvents.YourTurnResponse event){
+        if (isOnline()){
+            ((SupportsOnlinePlay) this.gameThreadBehaviour).onYourTurn(event.clientId());
+        }
+    }
+
+    public void onMoveReceived(NetworkEvents.GameMoveResponse event){
+        if (isOnline()){
+            ((SupportsOnlinePlay) this.gameThreadBehaviour).onMoveReceived(
+                    translateMove(Integer.parseInt(event.move())));
+        }
+    }
+
+    public void gameFinished(NetworkEvents.GameResultResponse event){
+        if (isOnline()){
+            ((SupportsOnlinePlay) this.gameThreadBehaviour).gameFinished(event.condition());
+        }
+    }
+
+    @Override
+    public void sendMove(long clientId, long move) {
+        new EventFlow().addPostEvent(NetworkEvents.SendMove.class, clientId, (short) Long.numberOfTrailingZeros(move)).asyncPostEvent();
+    }
+
+    @Override
+    public void updateUI() {
+        TurnBasedGame gameCopy = game.deepCopy();
+        canvas.redraw(gameCopy);
+        String gameType = game.getClass().getSimpleName().replace("Bitboard","");
+        gameView.nextPlayer(true, getCurrentPlayer().getName(), game.getPlayer(1-getCurrentPlayerIndex()).getName(),gameType);
+        if (getCurrentPlayer() instanceof LocalPlayer && gameType.equals("Reversi")){
+            ((ReversiBitCanvas)canvas).drawLegalDots(gameCopy);
+        }
+    }
+}

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

@@ -0,0 +1,23 @@
+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.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);
+
+        super(new ReversiBitCanvas(), game, thread, "Reversi");
+    }
+}

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

@@ -1,138 +0,0 @@
-package org.toop.app.gameControllers;
-
-import javafx.animation.SequentialTransition;
-import javafx.geometry.Pos;
-import javafx.scene.paint.Color;
-import org.toop.app.App;
-import org.toop.app.canvas.ReversiCanvas;
-import org.toop.app.widget.WidgetContainer;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-import org.toop.framework.gameFramework.view.GUIEvents;
-import org.toop.game.gameThreads.LocalFixedRateThreadBehaviour;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.players.LocalPlayer;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.games.reversi.ReversiR;
-
-public class ReversiController extends AbstractGameController<ReversiR> {
-    // TODO: Refactor GUI update methods to follow designed system
-    public ReversiController(Player<ReversiR>[] players, boolean local) {
-        ReversiR ReversiR = new ReversiR(players);
-        super(
-                new ReversiCanvas(Color.GRAY, (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,(c) -> {new EventFlow().addPostEvent(GUIEvents.PlayerAttemptedMove.class, c).postEvent();}, (c) -> {new EventFlow().addPostEvent(GUIEvents.PlayerMoveHovered.class, c).postEvent();}),
-                players,
-                ReversiR,
-                local ? new LocalFixedRateThreadBehaviour<>(ReversiR, players) : new OnlineThreadBehaviour<>(ReversiR, players), // TODO: Player order matters here, this won't work atm
-                "Reversi");
-        eventFlow.listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}}, false);
-        eventFlow.listen(GUIEvents.PlayerMoveHovered.class, this::onHoverMove, false);
-        initUI();
-    }
-
-
-    private void onHoverMove(GUIEvents.PlayerMoveHovered event){
-        int cellEntered = event.move();
-        canvas.drawPlayerHover(-1, cellEntered, game);
-        /*// (information.players[game.getCurrentTurn()].isHuman) {
-            int[] legalMoves = game.getLegalMoves();
-            boolean isLegalMove = false;
-            for (int move : legalMoves) {
-                if (move == cellEntered){
-                    isLegalMove = true;
-                    break;
-                }
-            }
-
-            if (cellEntered >= 0){
-                int[] moves = null;
-                if (isLegalMove) {
-                    moves = game.getFlipsForPotentialMove(
-                            new Point(cellEntered%game.getColumnSize(),cellEntered/game.getRowSize()),
-                            game.getCurrentPlayer());
-                }
-                canvas.drawHighlightDots(moves);
-            }
-        //}*/
-    }
-
-    public ReversiController(Player<ReversiR>[] players) {
-        this(players, true);
-    }
-
-    private void updateCanvas(boolean animate) {
-        // Todo: this is very inefficient. still very fast but if the grid is bigger it might cause issues. improve.
-        canvas.clearAll();
-
-        for (int i = 0; i < game.getBoard().length; i++) {
-            if (game.getBoard()[i] == 0) {
-                canvas.drawDot(Color.WHITE, i);
-            } else if (game.getBoard()[i] == 1) {
-                canvas.drawDot(Color.BLACK, i);
-            }
-        }
-
-        final int[] flipped = game.getMostRecentlyFlippedPieces();
-
-        final SequentialTransition animation = new SequentialTransition();
-
-        final Color fromColor = getCurrentPlayerIndex() == 0? Color.WHITE : Color.BLACK;
-        final Color toColor = getCurrentPlayerIndex() == 0? Color.BLACK : Color.WHITE;
-
-        if (animate && flipped != null) {
-            for (final int flip : flipped) {
-                canvas.clear(flip);
-                canvas.drawDot(fromColor, flip);
-                animation.getChildren().addFirst(canvas.flipDot(fromColor, toColor, flip));
-            }
-        }
-
-        animation.setOnFinished(_ -> {
-
-            if (getCurrentPlayer() instanceof LocalPlayer) {
-                final int[] legalMoves = game.getLegalMoves();
-
-                for (final int legalMove : legalMoves) {
-                    drawLegalPosition(legalMove, getCurrentPlayerIndex());
-                }
-            }
-        });
-
-        animation.play();
-        primary.nextPlayer(true, getCurrentPlayer().getName(), game.getCurrentTurn() == 0 ? "X" : "O", getPlayer((game.getCurrentTurn() + 1) % 2).getName());
-    }
-
-    @Override
-    public void updateUI() {
-        updateCanvas(false);
-    }
-
-    public void drawLegalPosition(int cell, int player) {
-        Color innerColor;
-        if (player == 1) {
-            innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
-        }
-        else {
-            innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
-        }
-        canvas.drawInnerDot(innerColor, cell,false);
-    }
-
-    private void initUI(){
-        primary.add(Pos.CENTER, canvas.getCanvas());
-        WidgetContainer.getCurrentView().transitionNext(primary, true);
-        updateCanvas(false);
-    }
-
-    private void drawMoves(){
-        int[] board = game.getBoard();
-
-        // Draw each square
-        for (int i = 0; i < board.length; i++){
-            // If square isn't empty, draw player move
-            if (board[i] != AbstractGame.EMPTY){
-                canvas.drawPlayerMove(board[i], i);
-            }
-        }
-    }
-}

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

@@ -0,0 +1,23 @@
+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.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;
+
+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/gameControllers/TicTacToeController.java

@@ -1,63 +0,0 @@
-package org.toop.app.gameControllers;
-
-import javafx.geometry.Pos;
-import javafx.scene.paint.Color;
-import org.toop.app.App;
-import org.toop.app.canvas.TicTacToeCanvas;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.framework.gameFramework.view.GUIEvents;
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-import org.toop.game.gameThreads.LocalThreadBehaviour;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.players.LocalPlayer;
-import org.toop.app.widget.WidgetContainer;
-import org.toop.game.games.tictactoe.TicTacToeR;
-
-public class TicTacToeController extends AbstractGameController<TicTacToeR> {
-
-    public TicTacToeController(Player<TicTacToeR>[] players, boolean local) {
-        TicTacToeR ticTacToeR = new TicTacToeR(players);
-        super(
-                new TicTacToeCanvas(Color.GRAY, (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,(c) -> {new EventFlow().addPostEvent(GUIEvents.PlayerAttemptedMove.class, c).postEvent();}),
-                players,
-                ticTacToeR,
-                local ? new LocalThreadBehaviour(ticTacToeR, players) : new OnlineThreadBehaviour<>(ticTacToeR, players), // TODO: Player order matters here, this won't work atm
-                "TicTacToe");
-
-        initUI();
-        eventFlow.listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}}, false);
-        //addListener(GlobalEventBus.subscribe(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}}));
-        //new EventFlow().listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer lp){lp.setMove(event.move());}});
-    }
-
-    public TicTacToeController(Player<TicTacToeR>[] players) {
-        this(players, true);
-    }
-
-    @Override
-    public void updateUI() {
-        canvas.clearAll();
-        // TODO: wtf is even this pile of poop temp fix
-        primary.nextPlayer(true, getCurrentPlayer().getName(), game.getCurrentTurn() == 0 ? "X" : "O", getPlayer((game.getCurrentTurn() + 1) % 2).getName());
-        drawMoves();
-    }
-
-    private void initUI(){
-        primary.add(Pos.CENTER, canvas.getCanvas());
-        WidgetContainer.getCurrentView().transitionNext(primary, true);
-        updateUI();
-    }
-
-    private void drawMoves(){
-        int[] board = game.getBoard();
-
-        // Draw each square
-        for (int i = 0; i < board.length; i++){
-            // If square isn't empty, draw player move
-            if (board[i] != AbstractGame.EMPTY){
-                canvas.drawPlayerMove(board[i], i);
-            }
-        }
-    }
-}

app/src/main/java/org/toop/app/widget/Primitive.java

@@ -6,7 +6,6 @@ import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.resource.resources.ImageAsset;
 import org.toop.local.AppContext;
 
-import java.io.File;
 import java.util.function.Consumer;
 
 import javafx.collections.FXCollections;
@@ -65,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");
 
@@ -76,6 +75,7 @@ public final class Primitive {
 
 		if (onAction != null) {
 			button.setOnAction(_ -> {
+				if (disableOnClick) button.setDisable(true);
                 onAction.run();
                 playButtonSound();
             });
@@ -84,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/Widget.java

@@ -2,19 +2,27 @@ package org.toop.app.widget;
 
 import javafx.geometry.Pos;
 import javafx.scene.Node;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 public interface Widget {
+    Logger logger = LogManager.getLogger(Widget.class);
+
 	Node getNode();
 
     default void show(Pos position) {
+        logger.debug("Showing Widget: {} at position: {}", this.getNode(), position.toString());
         WidgetContainer.add(position, this);
     }
 
     default void hide() {
+        logger.debug("Hiding Widget: {}", this.getNode());
         WidgetContainer.remove(this);
     }
 
     default void replace(Pos position, Widget widget) {
+        logger.debug("Replacing Widget: {}, with widget: {}, to position: {}",
+                this.getNode(), widget.getNode(), position.toString());
         widget.show(position);
 		hide();
     }

app/src/main/java/org/toop/app/widget/WidgetContainer.java

@@ -1,5 +1,6 @@
 package org.toop.app.widget;
 
+import javafx.scene.Node;
 import org.toop.app.widget.complex.PopupWidget;
 import org.toop.app.widget.complex.ViewWidget;
 
@@ -7,6 +8,10 @@ import javafx.application.Platform;
 import javafx.geometry.Pos;
 import javafx.scene.layout.StackPane;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Predicate;
+
 public final class WidgetContainer {
 	private static StackPane root;
 	private static ViewWidget currentView;
@@ -38,7 +43,7 @@ public final class WidgetContainer {
 				root.getChildren().addFirst(view.getNode());
 				currentView = view;
 			} else if (widget instanceof PopupWidget popup) {
-				currentView.add(Pos.CENTER, popup);
+				currentView.add(Pos.CENTER, (Widget) popup);
 			} else {
 				root.getChildren().add(widget.getNode());
 			}
@@ -52,13 +57,61 @@ public final class WidgetContainer {
 
 		Platform.runLater(() -> {
 			if (widget instanceof PopupWidget popup) {
-				currentView.remove(popup);
+				currentView.remove((Widget) popup);
 			} else {
 				root.getChildren().remove(widget.getNode());
 			}
 		});
 	}
 
+	public static void remove(Class<? extends Widget> widgetClass) {
+		if (root == null || currentView == null) return;
+
+		Platform.runLater(() ->
+				currentView.getChildren().removeIf(widget -> widget.getClass().isAssignableFrom(widgetClass))
+		);
+	}
+
+	public static void removeFirst(Class<? extends Widget> widgetClass) {
+		if (root == null || currentView == null) return;
+
+		Platform.runLater(() -> {
+			for (Node widget : currentView.getChildren()) {
+				if (widgetClass.isAssignableFrom(widget.getClass())) {
+					currentView.getChildren().remove(widget);
+					break;
+				}
+			}
+		});
+	}
+
+	public static List<Widget> find(Class<? extends Widget> widgetClass) {
+		if (root == null || currentView == null) return null;
+
+		return getAllWidgets()
+				.stream()
+				.filter(widget -> widget.getClass().isAssignableFrom(widgetClass))
+				.toList();
+    }
+
+	public static List<Widget> find(Predicate<Widget> predicate) {
+		if (root == null || currentView == null) return null;
+
+		return getAllWidgets()
+				.stream()
+				.filter(predicate)
+				.toList();
+	}
+
+	public static Widget findFirst(Class<? extends Widget> widgetClass) {
+		if (root == null || currentView == null) return null;
+
+		return getAllWidgets()
+				.stream()
+				.filter(widget -> widget.getClass().isAssignableFrom(widgetClass))
+				.findFirst().orElse(null);
+	}
+
 	public static ViewWidget getCurrentView() {
 		return currentView;
 	}
@@ -74,4 +127,22 @@ public final class WidgetContainer {
             currentView = view;
         });
     }
+
+	public static List<Widget> getAllWidgets() {
+		final List<Widget> children = new ArrayList<>();
+
+		for (var child : root.getChildren()) {
+			if (child instanceof Widget widget) {
+				children.add(widget);
+			}
+		}
+
+		for (var child : currentView.getNode().getChildren()) {
+			if (child instanceof Widget widget) {
+				children.add(widget);
+			}
+		}
+
+		return children;
+	}
 }

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

@@ -2,7 +2,7 @@ package org.toop.app.widget.complex;
 
 import javafx.application.Platform;
 import javafx.geometry.Pos;
-import javafx.scene.control.Control;
+import javafx.scene.Node;
 import javafx.scene.control.ProgressBar;
 import javafx.scene.control.ProgressIndicator;
 import javafx.scene.layout.VBox;
@@ -144,11 +144,11 @@ public class LoadingWidget extends ViewWidget implements Update { // TODO make o
 
         if (successTrigger.call()) {
             triggerSuccess();
-            this.remove(this);
+            this.remove((Node) this);
             return;
         } else if (failureTrigger.call()) {
             triggerFailure();
-            this.remove(this);
+            this.remove((Node) this);
             return;
         }
 

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

@@ -5,10 +5,13 @@ import org.toop.app.widget.Primitive;
 
 import javafx.scene.Node;
 import javafx.scene.layout.VBox;
+import javafx.scene.text.Text;
 
 public class PlayerInfoWidget {
 	private final GameInformation.Player information;
 	private final VBox container;
+    private Text playerName;
+    private boolean hasSet;
 
 	public PlayerInfoWidget(GameInformation.Player information) {
 		this.information = information;
@@ -16,10 +19,11 @@ public class PlayerInfoWidget {
 			buildToggle().getNode(),
 			buildContent()
 		);
+        this.playerName = null;
 	}
 
 	private ToggleWidget buildToggle() {
-		return new ToggleWidget(
+        return new ToggleWidget(
 			"computer", "player",
 			information.isHuman,
 			isHuman -> {
@@ -33,51 +37,76 @@ public class PlayerInfoWidget {
 	}
 
 	private Node buildContent() {
-		if (information.isHuman) {
-			var nameInput = new LabeledInputWidget(
-				"name",
-				"enter-your-name",
-				information.name,
-				newName -> information.name = newName
-			);
 
-			return nameInput.getNode();
-		} else {
-			if (information.name == null || information.name.isEmpty()) {
-				information.name = "Pism Bot";
-			}
+        if (information.isHuman) {
+            var spacer = Primitive.vbox(
+                    makeAIButton(0, 0, "zwartepiet"),
+                    makeAIButton(0, 0, "sinterklaas"),
+                    makeAIButton(0, 0, "santa")
+            );                                                                  //todo make a better solution
+            spacer.setVisible(false);
+            var nameInput = new LabeledInputWidget(
+                    "name",
+                    "enter-your-name",
+                    information.name,
+                    newName -> information.name = newName
+            );
 
-			var playerName = Primitive.text("");
-			playerName.setText(information.name);
+            return Primitive.vbox(spacer,nameInput.getNode());
+        } else {
+            var AIBox = Primitive.vbox(
+                    makeAIButton(0, 1, "zwartepiet"),
+                    makeAIButton(2, 1, "sinterklaas"),
+                    makeAIButton(9, 1, "santa")
+            );
 
-			var nameDisplay = Primitive.vbox(
-				Primitive.text("name"),
-				playerName
-			);
+            this.playerName = Primitive.text("");
+            playerName.setText(information.name);
 
-			var difficultySlider = new LabeledSliderWidget(
-				"computer-difficulty",
-				0, 5,
-				information.computerDifficulty,
-				newVal -> information.computerDifficulty = newVal
-			);
+            var nameDisplay = Primitive.vbox(
+                    Primitive.text("name"),
+                    playerName
+            );
 
-			var thinkTimeSlider = new LabeledSliderWidget(
-				"computer-think-time",
-				0, 5,
-				information.computerThinkTime,
-				newVal -> information.computerThinkTime = newVal
-			);
+            if (!hasSet) {
+                doDefault();
+                hasSet = true;
+            }
 
-			return Primitive.vbox(
-				nameDisplay,
-				difficultySlider.getNode(),
-				thinkTimeSlider.getNode()
-			);
-		}
-	}
+            return Primitive.vbox(
+                    AIBox,
+                    nameDisplay
+            );
+
+        }
+    }
 
 	public Node getNode() {
 		return container;
 	}
+
+    private Node makeAIButton(int depth, int thinktime, String name) {
+        return Primitive.button(name, () -> {
+            information.name = getName(name);
+            information.computerDifficulty = depth;
+            information.computerThinkTime = thinktime;
+            this.playerName.setText(getName(name));
+        }, false);
+    }
+
+    private String getName(String name) {
+        return switch (name) {
+            case "sinterklaas" -> "Sint. R. Klaas";
+            case "zwartepiet" -> "Zwarte Piet";
+            case "santa" -> "Santa";
+            default -> "Default";
+        };
+    }
+
+    private void doDefault() {
+        information.name = getName("zwartepiet");
+        information.computerDifficulty = 0;
+        information.computerThinkTime = 1;
+        this.playerName.setText(getName("zwartepiet"));
+    }
 }

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

@@ -7,22 +7,19 @@ import javafx.geometry.Pos;
 import javafx.scene.Node;
 import javafx.scene.layout.StackPane;
 
-public abstract class StackWidget implements Widget {
-    private final StackPane container;
-
+public abstract class StackWidget extends StackPane implements Widget {
 	public StackWidget(String cssClass) {
-        container = new StackPane();
-		container.getStyleClass().add(cssClass);
+		this.getStyleClass().add(cssClass);
 	}
 
 	public void add(Pos position, Node node) {
 		Platform.runLater(() -> {
-			if (container.getChildren().contains(node)) {
+			if (this.getChildren().contains(node)) {
 				return;
 			}
 
 			StackPane.setAlignment(node, position);
-			container.getChildren().add(node);
+			this.getChildren().add(node);
 		});
 	}
 
@@ -32,7 +29,7 @@ public abstract class StackWidget implements Widget {
 
 	public void remove(Node node) {
 		Platform.runLater(() -> {
-			container.getChildren().remove(node);
+			this.getChildren().remove(node);
 		});
 	}
 
@@ -41,7 +38,7 @@ public abstract class StackWidget implements Widget {
 	}
 
 	@Override
-	public Node getNode() {
-		return container;
+	public StackPane getNode() {
+		return this;
 	}
 }

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,11 +32,24 @@ public abstract class ViewWidget extends StackWidget {
 
 		var backButton = Primitive.button("back", () -> {
 			view.transitionPrevious();
-		});
+		}, false);
 
 		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(backButton));
 	}
 
+	public void transitionNextCustom(ViewWidget view, String key, Runnable runnable) {
+		view.previous = this;
+
+		replace(Pos.CENTER, view);
+
+		var customButton = Primitive.button(key, () -> {
+			runnable.run();
+			view.transitionPrevious();
+		}, false);
+
+		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(customButton));
+	}
+
 	public void transitionPrevious() {
 		if (previous == null) {
 			return;
@@ -46,13 +59,45 @@ public abstract class ViewWidget extends StackWidget {
 		previous = null;
 	}
 
+	public void removeIndexFromPreviousChain(int index) {
+		ViewWidget view = this;
+
+		while (index > 0 && view != null) {
+			index--;
+
+			if (index == 0) {
+				if (view.previous != null && view.previous.previous != null) {
+					view.previous = view.previous.previous;
+				}
+			}
+
+			view = view.previous;
+		}
+	}
+
+	public void removeViewFromPreviousChain(ViewWidget view) {
+		ViewWidget prev = previous;
+		int index = 0;
+
+		while (prev != null) {
+			index++;
+
+			if (prev == view) {
+				removeIndexFromPreviousChain(index);
+				break;
+			}
+
+			prev = prev.previous;
+		}
+	}
+
 	public void reload(ViewWidget view) {
 		view.previous = previous;
 		replace(Pos.CENTER, view);
 
 		var backButton = Primitive.button("back", () -> {
 			view.transitionPrevious();
-		});
+		}, false);
 
 		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(backButton));
 	}

app/src/main/java/org/toop/app/widget/display/SongDisplay.java

@@ -49,11 +49,11 @@ public class SongDisplay extends VBox implements Widget {
 		previousButton.getStyleClass().setAll("previous-button");
 
 		skipButton.setOnAction( event -> {
-			GlobalEventBus.post(new AudioEvents.SkipMusic());
+			GlobalEventBus.get().post(new AudioEvents.SkipMusic());
 		});
 
 		pauseButton.setOnAction(event -> {
-			GlobalEventBus.post(new AudioEvents.PauseMusic());
+			GlobalEventBus.get().post(new AudioEvents.PauseMusic());
 			if (pauseButton.getText().equals("⏸")) {
 				pauseButton.setText("▶");
 			}
@@ -63,7 +63,7 @@ public class SongDisplay extends VBox implements Widget {
 		});
 
 		previousButton.setOnAction( event -> {
-			GlobalEventBus.post(new AudioEvents.PreviousMusic());
+			GlobalEventBus.get().post(new AudioEvents.PreviousMusic());
 		});
 
 		HBox control = new HBox(10, previousButton, pauseButton, skipButton);

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

@@ -8,6 +8,7 @@ import org.toop.app.widget.complex.PopupWidget;
 import java.util.function.Consumer;
 
 import javafx.geometry.Pos;
+import org.toop.local.AppContext;
 
 public final class ChallengePopup extends PopupWidget {
 	private final GameInformation.Player playerInformation;
@@ -28,19 +29,22 @@ public final class ChallengePopup extends PopupWidget {
 	private void setupLayout() {
 		var challengeText = Primitive.text("you-were-challenged-by");
 
-		var challengerHeader = Primitive.header("");
-		challengerHeader.setText(challenger);
+		var challengerHeader = Primitive.header(challenger, false);
 
-		var gameText = Primitive.text("to-a-game-of");
-		gameText.setText(gameText.getText() + " " + game);
+		var toAGameOfText = Primitive.text("to-a-game-of");
+		var gameHeader = Primitive.header(game, false);
 
-		var acceptButton = Primitive.button("accept", () -> onAccept.accept(playerInformation));
-		var denyButton = Primitive.button("deny", () -> hide());
+		var acceptButton = Primitive.button("accept", () -> {
+			onAccept.accept(playerInformation);
+			this.hide();
+		}, false);
+		var denyButton = Primitive.button("deny", () -> hide(), false);
 
 		var leftSection = Primitive.vbox(
 			challengeText,
 			challengerHeader,
-			gameText,
+			toAGameOfText,
+			gameHeader,
 			Primitive.separator(),
 			Primitive.hbox(
 				acceptButton,

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

@@ -0,0 +1,48 @@
+package org.toop.app.widget.popup;
+
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import org.toop.app.widget.Primitive;
+import org.toop.app.widget.Widget;
+import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.PopupWidget;
+import org.toop.app.widget.complex.ViewWidget;
+import org.toop.app.widget.view.GameView;
+import org.toop.app.widget.view.OptionsView;
+import org.toop.local.AppContext;
+
+import java.util.ArrayList;
+
+public class EscapePopup extends PopupWidget {
+    public EscapePopup() {
+        ViewWidget currentView = WidgetContainer.getCurrentView();
+        ArrayList<Node> nodes = new ArrayList<>();
+
+        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);
+        }
+
+        if (currentView.getClass().isAssignableFrom(GameView.class)) {
+            Widget tut = AppContext.currentTutorial();
+            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/GameOverPopup.java

@@ -2,7 +2,6 @@ package org.toop.app.widget.popup;
 
 import org.toop.app.widget.complex.ConfirmWidget;
 import org.toop.app.widget.complex.PopupWidget;
-import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
 

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

@@ -15,14 +15,12 @@ public class QuitPopup extends PopupWidget {
 		});
 
 		confirmWidget.addButton("no", () -> {
-			App.stopQuit();
 			hide();
 		});
 
 		add(Pos.CENTER, confirmWidget);
 
 		setOnPop(() -> {
-			App.stopQuit();
 			hide();
 		});
 	}

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

@@ -34,7 +34,7 @@ public final class SendChallengePopup extends PopupWidget {
 		// --- Left side: challenge text and buttons ---
 		var challengeText = Primitive.text("challenge");
 
-		var opponentHeader = Primitive.header(opponent);
+		var opponentHeader = Primitive.header(opponent, false);
 
 		var gameText = Primitive.text("to-a-game-of");
 
@@ -61,10 +61,10 @@ public final class SendChallengePopup extends PopupWidget {
 
 		var sendButton = Primitive.button(
 			"send",
-			() -> onSend.accept(playerInformation, gameChoice.getValue())
-		);
+			() -> { 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

@@ -7,7 +7,6 @@ import javafx.scene.text.Text;
 import org.apache.maven.surefire.shared.lang3.tuple.ImmutablePair;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.Updatable;
-import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.complex.PopupWidget;
 
 import org.toop.framework.resource.resources.ImageAsset;
@@ -48,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,
@@ -59,8 +58,6 @@ public class BaseTutorialWidget extends PopupWidget implements Updatable {
         var x = Primitive.vbox(imagery, tutorialText);
 
         add(Pos.CENTER, Primitive.vbox(x, w));
-
-        WidgetContainer.add(Pos.CENTER, this);
     }
 
     @Override

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

@@ -1,37 +1,48 @@
 package org.toop.app.widget.view;
 
+import javafx.scene.paint.Color;
+import javafx.scene.shape.Circle;
+import javafx.scene.text.Font;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.ViewWidget;
 import org.toop.app.widget.popup.GameOverPopup;
 
+import java.util.Objects;
 import java.util.function.Consumer;
-
 import javafx.application.Platform;
 import javafx.geometry.Pos;
 import javafx.scene.control.Button;
 import javafx.scene.control.TextField;
 import javafx.scene.text.Text;
-import org.toop.app.widget.tutorial.BaseTutorialWidget;
 import org.toop.app.widget.tutorial.Connect4TutorialWidget;
 import org.toop.app.widget.tutorial.ReversiTutorialWidget;
 import org.toop.app.widget.tutorial.TicTacToeTutorialWidget;
+import org.toop.local.AppContext;
 
 public final class GameView extends ViewWidget {
-	private final Text currentPlayerHeader;
-	private final Text currentMoveHeader;
-	private final Text nextPlayerHeader;
+	private final Text playerHeader;
+	private final Text turnHeader;
+    private final Text player1Header;
+    private final Text player2Header;
+    private Circle player1Icon;
+    private Circle player2Icon;
 	private final Button forfeitButton;
 	private final Button exitButton;
-    private final Button tutorialButton;
     private final TextField chatInput;
+    private final Text keyThingy;
+    private boolean hasSet = false;
 
 	public GameView(Runnable onForfeit, Runnable onExit, Consumer<String> onMessage, String gameType) {
-		currentPlayerHeader = Primitive.header("");
-		currentMoveHeader = Primitive.header("");
-		nextPlayerHeader = Primitive.header("");
+		playerHeader = Primitive.header("");
+		turnHeader = Primitive.header("");
+        keyThingy = Primitive.text("turnof");
+        player1Header = Primitive.header("");
+        player2Header = Primitive.header("");
+        player1Icon = new Circle();
+        player2Icon = new Circle();
 
 		if (onForfeit != null) {
-			forfeitButton = Primitive.button("forfeit", () -> onForfeit.run());
+			forfeitButton = Primitive.button("forfeit", () -> onForfeit.run(), false);
 		} else {
 			forfeitButton = null;
 		}
@@ -39,7 +50,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);
@@ -51,32 +62,27 @@ public final class GameView extends ViewWidget {
 			chatInput = null;
 		}
 
-        switch(gameType) {
+        switch (gameType) {
             case "TicTacToe":
-                this.tutorialButton = Primitive.button("tutorialstring", () -> new TicTacToeTutorialWidget(() -> {})); break;
+                AppContext.setCurrentTutorial(new TicTacToeTutorialWidget(() -> {}));
+                break;
             case "Reversi":
-                this.tutorialButton = Primitive.button("tutorialstring", () -> new ReversiTutorialWidget(() -> {})); break;
+                AppContext.setCurrentTutorial(new ReversiTutorialWidget(() -> {}));
+                break;
             case "Connect4":
-                this.tutorialButton = Primitive.button("tutorialstring", () -> new Connect4TutorialWidget(() -> {})); break;
-            default:
-                this.tutorialButton = null; break;
+                AppContext.setCurrentTutorial(new Connect4TutorialWidget(() -> {}));
+                break;
         }
 
 		setupLayout();
 	}
 
 	private void setupLayout() {
-		var playerInfo = Primitive.vbox(
-			currentPlayerHeader,
-			Primitive.hbox(
-				Primitive.separator(),
-				currentMoveHeader,
-				Primitive.separator()
-			),
-			nextPlayerHeader
-		);
+        var turnInfo = Primitive.vbox(
+                turnHeader
+        );
 
-		add(Pos.TOP_RIGHT, playerInfo);
+        add(Pos.TOP_CENTER, turnInfo);
 
 		var buttons = Primitive.vbox(
 			forfeitButton,
@@ -88,27 +94,88 @@ public final class GameView extends ViewWidget {
 		if (chatInput != null) {
 			add(Pos.BOTTOM_RIGHT, Primitive.vbox(chatInput));
 		}
-
-        if (tutorialButton != null) {
-            add(Pos.TOP_LEFT, tutorialButton);
-        }
 	}
 
-	public void nextPlayer(boolean isMe, String currentPlayer, String currentMove, String nextPlayer) {
+	public void nextPlayer(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
 		Platform.runLater(() -> {
-			currentPlayerHeader.setText(currentPlayer);
-			currentMoveHeader.setText(currentMove);
-			nextPlayerHeader.setText(nextPlayer);
-
-			if (isMe) {
-				currentPlayerHeader.getStyleClass().add("my-turn");
-			} else {
-				currentPlayerHeader.getStyleClass().remove("my-turn");
-			}
+            if (!(hasSet)) {
+                playerHeader.setText(currentPlayer + " vs. " + nextPlayer);
+                hasSet = true;
+                setPlayerHeaders(isMe, currentPlayer, nextPlayer, GameType);
+            }
+            //TODO idk if theres any way to check this? only EN uses 's and the rest doesnt. if theres a better way to do this pls let me know
+            if (AppContext.getLocale().toLanguageTag().equals("en")) {
+                turnHeader.setText(currentPlayer + keyThingy.getText());
+            }
 		});
 	}
 
 	public void gameOver(boolean iWon, String winner) {
 		new GameOverPopup(iWon, winner).show(Pos.CENTER);
 	}
+
+    private void setPlayerHeaders(boolean isMe, String currentPlayer, String nextPlayer, String GameType) {
+        if (Objects.equals(GameType, "TicTacToe")) {
+            if (isMe) {
+                player1Header.setText("X: " + currentPlayer);
+                player2Header.setText("O: " + nextPlayer);
+            }
+            else {
+                player1Header.setText("X: " + nextPlayer);
+                player2Header.setText("O: " + currentPlayer);
+            }
+            setPlayerInfoTTT();
+        }
+        else if (Objects.equals(GameType, "Reversi")) {
+            if (isMe) {
+                player1Header.setText(currentPlayer);
+                player2Header.setText(nextPlayer);
+            }
+            else {
+                player1Header.setText(nextPlayer);
+                player2Header.setText(currentPlayer);
+            }
+            setPlayerInfoReversi();
+        }
+    }
+
+    private void setPlayerInfoTTT() {
+        var playerInfo = Primitive.vbox(
+                playerHeader,
+                Primitive.separator(),
+                player1Header,
+                player2Header
+        );
+
+        add(Pos.TOP_RIGHT, playerInfo);
+    }
+
+    private void setPlayerInfoReversi() {
+        var player1box = Primitive.hbox(
+                player1Icon,
+                player1Header
+        );
+
+        player1box.getStyleClass().add("hboxspacing");
+
+        var player2box = Primitive.hbox(
+                player2Icon,
+                player2Header
+        );
+
+        player2box.getStyleClass().add("hboxspacing");
+
+        var playerInfo = Primitive.vbox(
+                playerHeader,
+                Primitive.separator(),
+                player1box,
+                player2box
+        );
+
+        player1Icon.setRadius(player1Header.fontProperty().map(Font::getSize).getValue());
+        player2Icon.setRadius(player2Header.fontProperty().map(Font::getSize).getValue());
+        player1Icon.setFill(Color.WHITE);
+        player2Icon.setFill(Color.BLACK);
+        add(Pos.TOP_RIGHT, playerInfo);
+    }
 }

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

@@ -2,19 +2,21 @@ package org.toop.app.widget.view;
 
 import javafx.application.Platform;
 import org.toop.app.GameInformation;
-import org.toop.app.gameControllers.AbstractGameController;
-import org.toop.app.gameControllers.ReversiController;
-import org.toop.app.gameControllers.TicTacToeController;
+import org.toop.app.gameControllers.ReversiBitController;
+import org.toop.app.gameControllers.TicTacToeBitController;
+import org.toop.framework.game.players.LocalPlayer;
+import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.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.game.games.reversi.ReversiAIR;
-import org.toop.game.games.tictactoe.TicTacToeAIR;
 import org.toop.app.widget.tutorial.*;
+import org.toop.game.players.ai.MiniMaxAI;
+import org.toop.game.players.ai.mcts.MCTSAI1;
+import org.toop.game.players.ai.mcts.MCTSAI3;
+import org.toop.game.players.ai.mcts.MCTSAI4;
 import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
@@ -25,7 +27,7 @@ import org.toop.local.AppSettings;
 public class LocalMultiplayerView extends ViewWidget {
 	private final GameInformation information;
 
-    private AbstractGameController<?> gameController;
+    private GameController gameController;
 
 	public LocalMultiplayerView(GameInformation.Type type) {
 		this(new GameInformation(type));
@@ -44,68 +46,69 @@ public class LocalMultiplayerView extends ViewWidget {
 				}
 			}
 
-            // TODO: Fix this temporary ass way of setting the players (Only works for TicTacToe)
+            // TODO: Fix this temporary ass way of setting the players
             Player[] players = new Player[2];
 
 			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 TicTacToeAIR(), information.players[0].name);
+                        players[0] = new ArtificialPlayer(new MCTSAI1(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 TicTacToeAIR(), information.players[1].name);
+                        players[1] = new ArtificialPlayer(new MiniMaxAI(9), "MiniMax AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
                         new ShowEnableTutorialWidget(
                                 () -> new TicTacToeTutorialWidget(() -> {
-                                    gameController = new TicTacToeController(players);
+                                    gameController = new TicTacToeBitController(players);
                                     gameController.start();
                                 }),
                                 () -> Platform.runLater(() -> {
-                                    gameController = new TicTacToeController(players);
+                                    gameController = new TicTacToeBitController(players);
                                     gameController.start();
                                 }),
                                 () -> AppSettings.getSettings().setFirstTTT(false)
                         );
                     } else {
-                        gameController = new TicTacToeController(players);
+                        gameController = new TicTacToeBitController(players);
                         gameController.start();
                     }
                     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 ReversiAIR(), information.players[0].name);
+						// players[0] = new ArtificialPlayer(new RandomAI<BitboardReversi>(), "Random AI");
+						players[0] = new ArtificialPlayer(new MCTSAI4(500, 4), "MCTS V4 AI");
                     }
                     if (information.players[1].isHuman) {
-                        players[1] = new LocalPlayer<>(information.players[1].name);
+                        players[1] = new LocalPlayer(information.players[1].name);
                     } else {
-                        players[1] = new ArtificialPlayer<>(new ReversiAIR(), information.players[1].name);
+						players[1] = new ArtificialPlayer(new MCTSAI1(500), "MCTS V1 AI");
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(
                                 () -> new ReversiTutorialWidget(() -> {
-                                    gameController = new ReversiController(players);
+                                    gameController = new ReversiBitController(players);
                                     gameController.start();
                                 }),
                                 () -> Platform.runLater(() -> {
-                                    gameController = new ReversiController(players);
+                                    gameController = new ReversiBitController(players);
                                     gameController.start();
                                 }),
                                 () -> AppSettings.getSettings().setFirstReversi(false)
                         );
                     } else {
-                        gameController = new ReversiController(players);
+                        gameController = new ReversiBitController(players);
                         gameController.start();
                     }
                     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

@@ -1,31 +1,32 @@
 package org.toop.app.widget.view;
 
-import org.toop.app.App;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.ViewWidget;
 import javafx.geometry.Pos;
+import org.toop.app.widget.popup.QuitPopup;
 
 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", () -> {
-			App.startQuit();
-		});
+			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

@@ -3,10 +3,17 @@ package org.toop.app.widget.view;
 import org.toop.app.Server;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.LabeledInputWidget;
-import org.toop.app.widget.complex.LoadingWidget;
 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() {
@@ -22,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,
@@ -33,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/OptionsView.java

@@ -74,7 +74,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.MASTERVOLUME))
-					.asyncPostEvent();
+					.postEvent();
 			}
 		);
 
@@ -86,7 +86,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setFxVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.FX))
-					.asyncPostEvent();
+					.postEvent();
 			}
 		);
 
@@ -98,7 +98,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setMusicVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.MUSIC))
-					.asyncPostEvent();
+					.postEvent();
 			}
 		);
 

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

@@ -1,50 +1,89 @@
 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 Runnable onDisconnect;
+	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, Runnable onDisconnect) {
+	public ServerView(String user, Consumer<String> onPlayerClicked, String userName, long clientId) {
 		this.user = user;
 		this.onPlayerClicked = onPlayerClicked;
-		this.onDisconnect = onDisconnect;
+		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);
 
-		var playerListSection = Primitive.vbox(
-			playerHeader,
-			Primitive.separator(),
-			listView
-		);
+        if (userName.equals("host")) { // TODO is fragile
+            var tournamentButton = Primitive.hbox(
+                    gameListTour,
+                    Primitive.button(
+                            "tournament",
+                            () -> GlobalEventBus.get().post(new NetworkEvents.SendCommand(clientId, "tournament", "start", gameListTour.getValue())),
+                            false,
+                            false
+                    )
+            );
 
-		add(Pos.CENTER, playerListSection);
+            add(Pos.BOTTOM_CENTER, tournamentButton);
+        } else {
+            subscribeButton = Primitive.button(
+                    "subscribe",
+                    () -> new EventFlow().addPostEvent(new NetworkEvents.SendSubscribe(clientId, gameListSub.getValue())).postEvent(),
+                    false,
+                    true
+            ); // TODO localize
 
-		var disconnectButton = Primitive.button("disconnect", () -> {
-			onDisconnect.run();
-			transitionPrevious();
-		});
+            var subscribe = Primitive.hbox(gameListSub, subscribeButton);
 
-		add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
+            var playerListSection = Primitive.vbox(
+                    playerHeader,
+                    Primitive.separator(),
+                    subscribe,
+                    listView
+            );
+
+            add(Pos.CENTER, playerListSection);
+
+            var disconnectButton = Primitive.button(
+                    "disconnect",
+					this::transitionPrevious,
+					false
+			);
+
+            add(Pos.BOTTOM_LEFT, Primitive.vbox(disconnectButton));
+        }
 	}
 
 	public void update(List<String> players) {
@@ -52,9 +91,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);
+	}
 }

app/src/main/java/org/toop/local/AppContext.java

@@ -1,10 +1,10 @@
 package org.toop.local;
 
-import java.util.Locale;
 import java.util.MissingResourceException;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.toop.app.widget.tutorial.BaseTutorialWidget;
 import org.toop.framework.resource.ResourceManager;
 import org.toop.framework.resource.resources.LocalizationAsset;
 
@@ -16,11 +16,13 @@ import javafx.beans.property.ObjectProperty;
 import javafx.beans.property.SimpleObjectProperty;
 
 public class AppContext {
+    private static final Logger logger = LogManager.getLogger(AppContext.class);
+
     private static final LocalizationAsset localization = ResourceManager.get("localization");
     private static Locale locale = Locale.forLanguageTag("en");
 
 	private static final ObjectProperty<Locale> localeProperty = new SimpleObjectProperty<>(locale);
-    private static final Logger logger = LogManager.getLogger(AppContext.class);
+    private static BaseTutorialWidget tutorialWidget;
 
     public static LocalizationAsset getLocalization() {
         return localization;
@@ -73,4 +75,12 @@ public class AppContext {
     public static StringBinding bindToKey(String key) {
         return bindToKey(key, true);
     }
+
+    public static void setCurrentTutorial(BaseTutorialWidget tutorial) {
+        AppContext.tutorialWidget = tutorial;
+    }
+
+    public static BaseTutorialWidget currentTutorial() {
+        return AppContext.tutorialWidget;
+    }
 }

app/src/main/java/org/toop/local/AppSettings.java

@@ -36,13 +36,13 @@ public class AppSettings {
 
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.volume, VolumeControl.MASTERVOLUME))
-				.asyncPostEvent();
+				.postEvent();
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.fxVolume, VolumeControl.FX))
-				.asyncPostEvent();
+				.postEvent();
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.musicVolume, VolumeControl.MUSIC))
-				.asyncPostEvent();
+				.postEvent();
 	}
 
 	public static SettingsAsset getPath() {

app/src/main/resources/localization/localization_ar.properties

@@ -85,6 +85,11 @@ reversi4=\u0627\u0644\u0644\u0627\u0639\u0628 \u0627\u0644\u0630\u064a \u064a\u0
 tutorialstring=\u0627\u0644\u062f\u0631\u0633 \u0627\u0644\u062a\u0648\u0636\u064a\u062d\u064a
 startgame=\u0627\u0628\u062f\u0623 \u0627\u0644\u0644\u0639\u0628\u0629!
 goback=\u0627\u0631\u062c\u0639
+turnof=\u062F\u0648\u0631\u0647
+zwartepiet=\u0633\u0647\u0644: Zwarte Piet
+sinterklaas=\u0645\u062a\u0648\u0633\u0637: Sint R. Klaas
+santa=\u0635\u0639\u0628: Santa
+
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629
 chinese=\u4e2d\u6587 (\u0627\u0644\u0635\u064a\u0646\u064a\u0629)

app/src/main/resources/localization/localization_de.properties

@@ -87,6 +87,10 @@ reversi4=Der Spieler, der am Ende die meisten Steine auf dem Brett hat, gewinnt.
 tutorialstring=Tutorial
 startgame=Spiel starten!
 goback=Zur<EFBFBD>ck
+turnof=ist dran
+zwartepiet=Leicht: Zwarte Piet
+sinterklaas=Mittel: Sint R. Klaas
+santa=Schwer: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinesisch)

app/src/main/resources/localization/localization_en.properties

@@ -24,6 +24,7 @@ error=Error
 exit=Exit
 forfeit=Forfeit
 fullscreen=Fullscreen
+game=REPLACE ME
 game-over=Game Over
 general=General
 high-contrast=High contrast
@@ -88,7 +89,10 @@ reversi4=The player who wins at the end of the game is the one who has the most
 tutorialstring=Tutorial
 startgame=Start game!
 goback=Go back
-
+turnof='s turn
+zwartepiet=Easy: Zwarte Piet
+sinterklaas=Medium: Sint R. Klaas
+santa=Hard:Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabic)
 chinese=\u4e2d\u6587 (Chinese)

app/src/main/resources/localization/localization_es.properties

@@ -86,7 +86,10 @@ reversi4=El jugador que gane al final del juego es quien tenga m
 tutorialstring=Tutorial
 startgame=\u00a1Iniciar juego!
 goback=Volver
-
+turnof=le toca
+zwartepiet=F\u00e1cil: Zwarte Piet
+sinterklaas=Medio: Sint R. Klaas
+santa=Dif\u00edcil: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Ar\u00e1bigo)
 chinese=\u4e2d\u6587 (Chino)

app/src/main/resources/localization/localization_fr.properties

@@ -86,6 +86,10 @@ reversi4=Le joueur qui a le plus de pions
 tutorialstring=Tutoriel
 startgame=D\u00e9marrer le jeu!
 goback=Retour
+turnof=\u00E0 son tour
+zwartepiet=Facile: Zwarte Piet
+sinterklaas=Moyen : Sint R. Klaas
+santa=Difficile: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabe)
 chinese=\u4e2d\u6587 (Chinois)

app/src/main/resources/localization/localization_hi.properties

@@ -86,6 +86,10 @@ reversi4=\u0916\u0941\u092f \u0915\u093f \u0915\u0940 \u0928\u093f\u092e\u0940 \
 tutorialstring=\u0924\u0942\u091f\u0949\u0930\u093f\u092f\u0932
 startgame=\u0916\u0947\u0932 \u0936\u0941\u0930\u0942 \u0915\u0930\u0947\u0902!
 goback=\u0935\u093e\u092a\u0938 \u091c\u093e\u090f\u0901
+turnof=\u0915\u0940 \u092C\u093E\u0930\u0940
+zwartepiet=\u0905\u0938\u093e\u0928: Zwarte Piet
+sinterklaas=\u092e\u0927\u094d\u092f\u092e: Sint R. Klaas
+santa=\u0915\u0924\u093f\u0928: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0905\u0930\u092c\u0940)
 chinese=\u4e2d\u6587 (\u091a\u0940\u0928\u0940)

app/src/main/resources/localization/localization_it.properties

@@ -85,6 +85,10 @@ reversi4=Il giocatore che alla fine del gioco ha pi
 tutorialstring=Tutorial
 startgame=Avvia il gioco!
 goback=Indietro
+turnof=\u00E8 il suo turno
+zwartepiet=Facile: Zwarte Piet
+sinterklaas=Medio: Sint R. Klaas
+santa=Difficile: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabo)
 chinese=\u4e2d\u6587 (Cinese)

app/src/main/resources/localization/localization_ja.properties

@@ -85,6 +85,10 @@ reversi4=\u672c\u6b21\u306b\u30dc\u30fc\u30c9\u4e0a\u3067\u6700\u591a\u306e\u8ca
 tutorialstring=\u30c1\u30e5\u30fc\u30c8\u30ea\u30a2\u30eb
 startgame=\u30b2\u30fc\u30e0\u3092\u958b\u59cb\uff01
 goback=\u623b\u308b
+turnof=\u306E\u756A
+zwartepiet=\u7c21\u5358: Zwarte Piet
+sinterklaas=\u4e2d\u7d1a: Sint R. Klaas
+santa=\u96e3\u3057\u3044: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u30a2\u30e9\u30d3\u30a2\u8a9e)
 chinese=\u4e2d\u6587 (\u4e2d\u6587)

app/src/main/resources/localization/localization_ko.properties

@@ -85,6 +85,10 @@ reversi4=\uacbd\uc6b0 \uc5d0\uc11c \ucd5c\ub300 \ud648\uc744 \uac00\uc838\ub294
 tutorialstring=\ud14c\ud2b8\ub9ad
 startgame=\uac8c\uc784 \uc2dc\uc791!
 goback=\ub4a4\ub85c \uac00\uae30
+turnof=\uC758 \uCC28\uB840
+zwartepiet=\uc218\uc601: Zwarte Piet
+sinterklaas=\ubcf4\ud1b5: Sint R. Klaas
+santa=\uc5d0\uc18c: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0639\u0631\u0628\u064a\u0629)
 chinese=\u4e2d\u6587 (\u4e2d\u6587)

app/src/main/resources/localization/localization_nl.properties

@@ -85,6 +85,10 @@ reversi4=De speler die aan het einde van het spel de meeste stukken op het bord
 tutorialstring=Tutorial
 startgame=Spel starten!
 goback=Ga terug
+turnof=is aan de beurt
+zwartepiet=Makkelijk: Zwarte Piet
+sinterklaas=Gemiddeld: Sint R. Klaas
+santa=Moeilijk: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinees)

app/src/main/resources/localization/localization_ru.properties

@@ -85,6 +85,10 @@ reversi4=\u0418043 \u0433043 \u0440043 \u043e043 \u043a043 \u043e043 \u0442043 \
 tutorialstring=\u0423\u0447\u0435\u0431\u043d\u0438\u043a
 startgame=\u041d\u0430\u0447\u0430\u0442\u044c \u0438\u0433\u0440\u0443!
 goback=\u041d\u0430\u0437\u0430\u0434
+turnof=\u0445\u043E\u0434\u0438\u0442
+zwartepiet=\u041b\u0435\u0433\u043a\u043e: Zwarte Piet
+sinterklaas=\u0421\u0440\u0435\u0434\u043d\u0438\u0439: Sint R. Klaas
+santa=\u0421\u043b\u043e\u0436\u043d\u043e: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0410\u0440\u0430\u0431\u0441\u043a\u0438\u0439)
 chinese=\u4e2d\u6587 (\u041a\u0438\u0442\u0430\u0439\u0441\u043a\u0438\u0439)

app/src/main/resources/localization/localization_zh.properties

@@ -85,6 +85,10 @@ reversi4=\u672c\u6e38\u620f\u7ed3\u675f\u65f6\u8d62\u5f97\u6ee1\u8fc7\u76d8\u976
 tutorialstring=\u6559\u7a0b
 startgame=\u5f00\u59cb\u6e38\u620f\uff01
 goback=\u8fd4\u56de
+turnof=\u7684\u56DE\u5408
+zwartepiet=\u7b80\u5355: Zwarte Piet
+sinterklaas=\u4e2d\u7b49: Sint R. Klaas
+santa=\u56f0\u96be: Santa
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u963f\u62c9\u4f2f\u8bed)
 chinese=\u4e2d\u6587

app/src/main/resources/style/dark.css

@@ -166,7 +166,7 @@
 	-fx-effect: dropshadow(gaussian, #88cc8899, 5, 0, 0, 1);
 }
 
-.my-turn {
+.text.my-turn {
 	-fx-fill: #e05656;
 	-fx-font-weight: bold;
 }

app/src/main/resources/style/high-contrast.css

@@ -164,7 +164,7 @@
 	-fx-effect: dropshadow(gaussian, #70e070cc, 6, 0, 0, 2);
 }
 
-.my-turn {
+.text.my-turn {
 	-fx-fill: #ff4b4b;
 	-fx-font-weight: bold;
 }

app/src/main/resources/style/large.css

@@ -23,6 +23,11 @@
 	-fx-spacing: 14;
 }
 
+.hboxspacing {
+    -fx-padding: 2;
+    -fx-spacing: 10;
+}
+
 .current-player {
 	-fx-font-size: 32px;
 }

app/src/main/resources/style/light.css

@@ -166,7 +166,7 @@
 	-fx-effect: dropshadow(gaussian, #aad3aa99, 4, 0, 0, 1);
 }
 
-.my-turn {
+.text.my-turn {
 	-fx-fill: #d14b4b;
 	-fx-font-weight: bold;
 }

app/src/main/resources/style/medium.css

@@ -23,6 +23,11 @@
 	-fx-spacing: 10;
 }
 
+.hboxspacing {
+    -fx-padding: 2;
+    -fx-spacing: 10;
+}
+
 .current-player {
 	-fx-font-size: 24px;
 }

app/src/main/resources/style/small.css

@@ -23,6 +23,11 @@
 	-fx-spacing: 6;
 }
 
+.hboxspacing {
+    -fx-padding: 2;
+    -fx-spacing: 10;
+}
+
 .current-player {
 	-fx-font-size: 16px;
 }

framework/pom.xml

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

framework/src/main/java/org/toop/framework/audio/AudioEventListener.java

@@ -5,26 +5,29 @@ import org.toop.framework.audio.interfaces.MusicManager;
 import org.toop.framework.audio.interfaces.SoundEffectManager;
 import org.toop.framework.audio.interfaces.VolumeManager;
 import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.framework.eventbus.bus.EventBus;
 import org.toop.framework.resource.types.AudioResource;
 
 public class AudioEventListener<T extends AudioResource, K extends AudioResource> {
+    private final EventBus eventBus;
     private final MusicManager<T> musicManager;
     private final SoundEffectManager<K> soundEffectManager;
     private final VolumeManager audioVolumeManager;
 
     public AudioEventListener(
+            EventBus eventBus,
             MusicManager<T> musicManager,
             SoundEffectManager<K> soundEffectManager,
             VolumeManager audioVolumeManager
     ) {
+        this.eventBus = eventBus;
         this.musicManager = musicManager;
         this.soundEffectManager = soundEffectManager;
         this.audioVolumeManager = audioVolumeManager;
     }
 
     public AudioEventListener<?, ?> initListeners(String buttonSoundToPlay) {
-        new EventFlow()
+        new EventFlow(eventBus)
                 .listen(AudioEvents.StopAudioManager.class, this::handleStopMusicManager, false)
                 .listen(AudioEvents.PlayEffect.class, this::handlePlaySound, false)
                 .listen(AudioEvents.SkipMusic.class, this::handleSkipSong, false)
@@ -73,7 +76,7 @@ public class AudioEventListener<T extends AudioResource, K extends AudioResource
     }
 
     private void handleGetVolume(AudioEvents.GetVolume event) {
-        GlobalEventBus.postAsync(new AudioEvents.GetVolumeResponse(
+        eventBus.post(new AudioEvents.GetVolumeResponse(
                 audioVolumeManager.getVolume(event.controlType()),
                 event.identifier()));
     }

framework/src/main/java/org/toop/framework/audio/MusicManager.java

@@ -6,8 +6,7 @@ import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.dispatch.interfaces.Dispatcher;
 import org.toop.framework.dispatch.JavaFXDispatcher;
 import org.toop.annotations.TestsOnly;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.framework.eventbus.bus.EventBus;
 import org.toop.framework.resource.types.AudioResource;
 
 import java.util.*;
@@ -18,6 +17,7 @@ import java.util.concurrent.TimeUnit;
 public class MusicManager<T extends AudioResource> implements org.toop.framework.audio.interfaces.MusicManager<T> {
     private static final Logger logger = LogManager.getLogger(MusicManager.class);
 
+    private final EventBus eventBus;
     private final List<T> backgroundMusic = new ArrayList<>();
     private final Dispatcher dispatcher;
     private final List<T> resources;
@@ -27,7 +27,8 @@ public class MusicManager<T extends AudioResource> implements org.toop.framework
     private ScheduledExecutorService scheduler;
 
 
-    public MusicManager(List<T> resources, boolean shuffleMusic) {
+    public MusicManager(EventBus eventbus, List<T> resources, boolean shuffleMusic) {
+        this.eventBus = eventbus;
         this.dispatcher = new JavaFXDispatcher();
         this.resources = resources;
         // Shuffle if wanting to shuffle
@@ -40,7 +41,8 @@ public class MusicManager<T extends AudioResource> implements org.toop.framework
      * {@code @TestsOnly} DO NOT USE
      */
     @TestsOnly
-    public MusicManager(List<T> resources, Dispatcher dispatcher) {
+    public MusicManager(EventBus eventBus, List<T> resources, Dispatcher dispatcher) {
+        this.eventBus = eventBus;
         this.dispatcher = dispatcher;
         this.resources = new ArrayList<>(resources);
         backgroundMusic.addAll(resources);
@@ -124,7 +126,7 @@ public class MusicManager<T extends AudioResource> implements org.toop.framework
         Runnable currentMusicTask = new Runnable() {
             @Override
             public void run() {
-                GlobalEventBus.post(new AudioEvents.PlayingMusic(track.getName(), track.currentPosition(), track.duration()));
+                eventBus.post(new AudioEvents.PlayingMusic(track.getName(), track.currentPosition(), track.duration()));
                 scheduler.schedule(this, 1, TimeUnit.SECONDS);
             }
         };

framework/src/main/java/org/toop/framework/audio/SoundEffectManager.java

@@ -2,18 +2,10 @@ package org.toop.framework.audio;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.toop.framework.resource.ResourceManager;
 import org.toop.framework.resource.ResourceMeta;
 import org.toop.framework.resource.resources.BaseResource;
-import org.toop.framework.resource.resources.MusicAsset;
-import org.toop.framework.resource.resources.SoundEffectAsset;
 import org.toop.framework.resource.types.AudioResource;
 
-import javax.sound.sampled.Clip;
-import javax.sound.sampled.LineEvent;
-import javax.sound.sampled.LineUnavailableException;
-import javax.sound.sampled.UnsupportedAudioFileException;
-import java.io.IOException;
 import java.util.*;
 import java.util.stream.Collectors;
 

framework/src/main/java/org/toop/framework/audio/events/AudioEvents.java

@@ -2,8 +2,6 @@ package org.toop.framework.audio.events;
 
 import org.toop.framework.audio.VolumeControl;
 import org.toop.framework.eventbus.events.*;
-import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
-import org.toop.framework.eventbus.events.UniqueEvent;
 
 public class AudioEvents extends EventsBase {
     /** Stops the audio manager. */

framework/src/main/java/org/toop/framework/audio/interfaces/SoundEffectManager.java

@@ -1,12 +1,7 @@
 package org.toop.framework.audio.interfaces;
 
-import org.toop.framework.resource.resources.SoundEffectAsset;
 import org.toop.framework.resource.types.AudioResource;
 
-import javax.sound.sampled.LineUnavailableException;
-import javax.sound.sampled.UnsupportedAudioFileException;
-import java.io.IOException;
-
 public interface SoundEffectManager<T extends AudioResource> extends AudioManager<T> {
     void play(String name, boolean loop);
     void stop(String name);

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

@@ -13,10 +13,14 @@ import org.toop.framework.SnowflakeGenerator;
 import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
 import org.toop.framework.eventbus.events.UniqueEvent;
+import org.toop.framework.eventbus.bus.EventBus;
+import org.toop.framework.eventbus.subscriber.DefaultNamedSubscriber;
+import org.toop.framework.eventbus.subscriber.NamedSubscriber;
+import org.toop.framework.eventbus.subscriber.Subscriber;
 
 /**
  * EventFlow is a utility class for creating, posting, and optionally subscribing to events in a
- * type-safe and chainable manner. It is designed to work with the {@link GlobalEventBus}.
+ * type-safe and chainable manner. It is designed to work with the {@link EventBus}.
  *
  * <p>This class supports automatic UUID assignment for {@link UniqueEvent} events, and
  * allows filtering subscribers so they only respond to events with a specific UUID. All
@@ -31,6 +35,8 @@ public class EventFlow {
     /** Cache of constructor handles for event classes to avoid repeated reflection lookups. */
     private static final Map<Class<?>, MethodHandle> CONSTRUCTOR_CACHE = new ConcurrentHashMap<>();
 
+    private final EventBus eventBus;
+
     /** Automatically assigned UUID for {@link UniqueEvent} events. */
     private long eventSnowflake = -1;
 
@@ -38,13 +44,19 @@ public class EventFlow {
     private EventType event = null;
 
     /** The listener returned by GlobalEventBus subscription. Used for unsubscription. */
-    private final List<ListenerHandler<?>> listeners = new ArrayList<>();
+    private final List<NamedSubscriber<?>> listeners = new ArrayList<>();
 
     /** Holds the results returned from the subscribed event, if any. */
     private Map<String, ?> result = null;
 
     /** Empty constructor (event must be added via {@link #addPostEvent(Class, Object...)}). */
-    public EventFlow() {}
+    public EventFlow(EventBus eventBus) {
+        this.eventBus = eventBus;
+    }
+
+    public EventFlow() {
+        this.eventBus = GlobalEventBus.get();
+    }
 
     /**
      *
@@ -145,21 +157,19 @@ public class EventFlow {
 
             action.accept(eventClass);
 
-            if (unsubscribeAfterSuccess) unsubscribe(id);
+            if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
 
             this.result = eventClass.result();
         };
 
-        // TODO Remove casts
-        var listener = new ListenerHandler<>(
-                id,
+        var subscriber = new DefaultNamedSubscriber<>(
                 name,
-                (Class<ResponseToUniqueEvent>) event,
-                (Consumer<ResponseToUniqueEvent>) newAction
+                event,
+                newAction
         );
 
-        GlobalEventBus.subscribe(listener);
-        this.listeners.add(listener);
+        eventBus.subscribe(subscriber);
+        this.listeners.add(subscriber);
         return this;
     }
 
@@ -227,7 +237,7 @@ public class EventFlow {
                     TT typedEvent = (TT) uuidEvent;
                     action.accept(typedEvent);
 
-                    if (unsubscribeAfterSuccess) unsubscribe(id);
+                    if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
 
                     this.result = typedEvent.result();
                 } catch (ClassCastException _) {
@@ -239,14 +249,13 @@ public class EventFlow {
             }
         };
 
-        var listener = new ListenerHandler<>(
-                id,
+        var listener = new DefaultNamedSubscriber<>(
                 name,
                 (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0],
                 newAction
         );
 
-        GlobalEventBus.subscribe(listener);
+        eventBus.subscribe(listener);
         this.listeners.add(listener);
         return this;
     }
@@ -284,17 +293,16 @@ public class EventFlow {
         Consumer<TT> newAction = eventc -> {
             action.accept(eventc);
 
-            if (unsubscribeAfterSuccess) unsubscribe(id);
+            if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
         };
 
-        var listener = new ListenerHandler<>(
-                        id,
+        var listener = new DefaultNamedSubscriber<>(
                         name,
                         event,
                         newAction
                 );
 
-        GlobalEventBus.subscribe(listener);
+        eventBus.subscribe(listener);
         this.listeners.add(listener);
         return this;
     }
@@ -362,7 +370,7 @@ public class EventFlow {
             try {
                 TT typedEvent = (TT) nonUuidEvent;
                 action.accept(typedEvent);
-                if (unsubscribeAfterSuccess) unsubscribe(id);
+                if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
             } catch (ClassCastException _) {
                 throw new ClassCastException(
                         "Cannot cast "
@@ -371,14 +379,13 @@ public class EventFlow {
             }
         };
 
-        var listener = new ListenerHandler<>(
-                id,
+        var listener = new DefaultNamedSubscriber<>(
                 name,
                 eventClass,
                 newAction
         );
 
-        GlobalEventBus.subscribe(listener);
+        eventBus.subscribe(listener);
         this.listeners.add(listener);
         return this;
     }
@@ -401,15 +408,16 @@ public class EventFlow {
      * Posts the event added through {@link #addPostEvent}.
      */
     public EventFlow postEvent() {
-        GlobalEventBus.post(this.event);
+        eventBus.post(this.event);
         return this;
     }
 
     /**
      * Posts the event added through {@link #addPostEvent} asynchronously.
+     *
      */
     public EventFlow asyncPostEvent() {
-        GlobalEventBus.postAsync(this.event);
+        GlobalEventBus.get().post(this.event);
         return this;
     }
 
@@ -417,28 +425,12 @@ public class EventFlow {
      *
      * Unsubscribe from an event.
      *
-     * @param listenerObject The listener object to remove and unsubscribe.
+     * @param action The listener object to remove and unsubscribe.
      */
-    public void unsubscribe(Object listenerObject) {
+    public void unsubscribe(Consumer<?> action) {
         this.listeners.removeIf(handler -> {
-            if (handler.getListener() == listenerObject) {
-                GlobalEventBus.unsubscribe(handler);
-                return true;
-            }
-            return false;
-        });
-    }
-
-    /**
-     *
-     * Unsubscribe from an event.
-     *
-     * @param listenerId The id given to the {@link ListenerHandler}.
-     */
-    public void unsubscribe(long listenerId) {
-        this.listeners.removeIf(handler -> {
-            if (handler.getId() == listenerId) {
-                GlobalEventBus.unsubscribe(handler);
+            if (handler.handler().equals(action)) {
+                eventBus.unsubscribe(handler);
                 return true;
             }
             return false;
@@ -452,8 +444,8 @@ public class EventFlow {
      */
     public void unsubscribe(String name) {
         this.listeners.removeIf(handler -> {
-            if (handler.getName().equals(name)) {
-                GlobalEventBus.unsubscribe(handler);
+            if (handler.id().equals(name)) {
+                eventBus.unsubscribe(handler);
                 return true;
             }
             return false;
@@ -465,7 +457,7 @@ public class EventFlow {
      */
     public void unsubscribeAll() {
         listeners.removeIf(handler -> {
-            GlobalEventBus.unsubscribe(handler);
+            eventBus.unsubscribe(handler);
             return true;
         });
     }
@@ -503,8 +495,8 @@ public class EventFlow {
      *
      * @return Copy of the list of listeners.
      */
-    public ListenerHandler[] getListeners() {
-        return listeners.toArray(new ListenerHandler[0]);
+    public Subscriber<?>[] getListeners() {
+        return listeners.toArray(new Subscriber[0]);
     }
 
     /**

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

@@ -1,193 +1,57 @@
 package org.toop.framework.eventbus;
 
-import com.lmax.disruptor.*;
-import com.lmax.disruptor.dsl.Disruptor;
-import com.lmax.disruptor.dsl.ProducerType;
-import java.util.Map;
-import java.util.concurrent.*;
-import java.util.function.Consumer;
-
 import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
+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.events.UniqueEvent;
+import org.toop.framework.eventbus.store.DefaultSubscriberStore;
+import org.toop.framework.eventbus.subscriber.Subscriber;
 
-/**
- * GlobalEventBus backed by the LMAX Disruptor for ultra-low latency, high-throughput event
- * publishing.
- */
-public final class GlobalEventBus {
-    private static final Logger logger = LogManager.getLogger(GlobalEventBus.class);
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
 
-    /** Map of event class to type-specific listeners. */
-    private static final Map<Class<?>, CopyOnWriteArrayList<ListenerHandler<?>>>
-            LISTENERS = new ConcurrentHashMap<>();
+public class GlobalEventBus implements AsyncEventBus {
+    private static final AsyncEventBus INSTANCE = new DefaultEventBus(
+            LogManager.getLogger(DefaultEventBus.class),
+            new DefaultSubscriberStore()
+    );
 
-    /** Map of event class to Snowflake-ID-specific listeners. */
-    private static final Map<
-                    Class<?>, ConcurrentHashMap<Long, Consumer<? extends UniqueEvent>>>
-            UUID_LISTENERS = new ConcurrentHashMap<>();
-
-    /** Disruptor ring buffer size (must be power of two). */
-    private static final int RING_BUFFER_SIZE = 1024 * 64;
-
-    /** Disruptor instance. */
-    private static final Disruptor<EventHolder> DISRUPTOR;
-
-    /** Ring buffer used for publishing events. */
-    private static final RingBuffer<EventHolder> RING_BUFFER;
-
-    static {
-        ThreadFactory threadFactory =
-                r -> {
-                    Thread t = new Thread(r, "EventBus-Disruptor");
-                    t.setDaemon(true);
-                    return t;
-                };
-
-        DISRUPTOR =
-                new Disruptor<>(
-                        EventHolder::new,
-                        RING_BUFFER_SIZE,
-                        threadFactory,
-                        ProducerType.MULTI,
-                        new BusySpinWaitStrategy());
-
-        DISRUPTOR.handleEventsWith(
-                (holder, seq, endOfBatch) -> {
-                    if (holder.event != null) {
-                        dispatchEvent(holder.event);
-                        holder.event = null;
-                    }
-                });
-
-        DISRUPTOR.start();
-        RING_BUFFER = DISRUPTOR.getRingBuffer();
-    }
-
-    /** Prevent instantiation. */
     private GlobalEventBus() {}
 
-    /** Wrapper used inside the ring buffer. */
-    private static class EventHolder {
-        EventType event;
+    public static EventBus get() {
+        return INSTANCE;
     }
 
-    // ------------------------------------------------------------------------
-    // Subscription
-    // ------------------------------------------------------------------------
-    public static <T extends EventType> void subscribe(ListenerHandler<T> listener) {
-        logger.debug("Subscribing to {}: {}", listener.getListenerClass().getSimpleName(), listener.getListener().getClass().getSimpleName());
-        LISTENERS.computeIfAbsent(listener.getListenerClass(), _ -> new CopyOnWriteArrayList<>()).add(listener);
+    @Override
+    public void subscribe(Subscriber<? extends EventType> listener) {
+        INSTANCE.subscribe(listener);
     }
 
-    // TODO
-    public static <T extends UniqueEvent> void subscribeById(
-            Class<T> eventClass, long eventId, Consumer<T> listener) {
-        UUID_LISTENERS
-                .computeIfAbsent(eventClass, _ -> new ConcurrentHashMap<>())
-                .put(eventId, listener);
+    @Override
+    public void unsubscribe(Subscriber<? extends EventType> listener) {
+        INSTANCE.unsubscribe(listener);
     }
 
-    public static void unsubscribe(ListenerHandler<?> listener) {
-        logger.debug("Unsubscribing from {}: {}", listener.getListenerClass().getSimpleName(), listener.getListener().getClass().getSimpleName());
-        LISTENERS.getOrDefault(listener.getListenerClass(), new CopyOnWriteArrayList<>())
-                .remove(listener);
-        LISTENERS.entrySet().removeIf(entry -> entry.getValue().isEmpty());
+    @Override
+    public <T extends EventType> void post(T event) {
+        INSTANCE.post(event);
     }
 
-    // TODO
-    public static <T extends UniqueEvent> void unsubscribeById(
-            Class<T> eventClass, long eventId) {
-        Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(eventClass);
-        if (map != null) map.remove(eventId);
+    @Override
+    public <T extends EventType> void asyncPost(T event) {
+        INSTANCE.asyncPost(event);
     }
 
-    // ------------------------------------------------------------------------
-    // Posting
-    // ------------------------------------------------------------------------
-    public static <T extends EventType> void post(T event) {
-        dispatchEvent(event); // synchronous
+    @Override
+    public void shutdown() {
+        INSTANCE.shutdown();
     }
 
-    public static <T extends EventType> void postAsync(T event) {
-        long seq = RING_BUFFER.next();
-        try {
-            EventHolder holder = RING_BUFFER.get(seq);
-            holder.event = event;
-        } finally {
-            RING_BUFFER.publish(seq);
-        }
+    @Override
+    public void reset() {
+        INSTANCE.reset();
     }
 
-    @SuppressWarnings("unchecked")
-    private static <T extends EventType> void callListener(ListenerHandler<?> raw, EventType event) {
-        ListenerHandler<T> handler = (ListenerHandler<T>) raw;
-        Consumer<T> listener = handler.getListener();
-
-        T casted = (T) event;
-
-        listener.accept(casted);
-    }
-
-    @SuppressWarnings("unchecked")
-    private static void dispatchEvent(EventType event) {
-        Class<?> clazz = event.getClass();
-
-        logger.debug("Triggered event: {}", event.getClass().getSimpleName());
-
-        CopyOnWriteArrayList<ListenerHandler<?>> classListeners = LISTENERS.get(clazz);
-        if (classListeners != null) {
-            for (ListenerHandler<?> listener : classListeners) {
-                try {
-                    callListener(listener, event);
-                } catch (Throwable e) {
-                    e.printStackTrace();
-                }
-            }
-        }
-
-        CopyOnWriteArrayList<ListenerHandler<?>> genericListeners = LISTENERS.get(Object.class);
-        if (genericListeners != null) {
-            for (ListenerHandler<?> listener : genericListeners) {
-                try {
-                    callListener(listener, event);
-                } catch (Throwable e) {
-                     e.printStackTrace();
-                }
-            }
-        }
-
-        if (event instanceof UniqueEvent snowflakeEvent) {
-            Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(clazz);
-            if (map != null) {
-                Consumer<UniqueEvent> listener =
-                        (Consumer<UniqueEvent>) map.remove(snowflakeEvent.getIdentifier());
-                if (listener != null) {
-                    try {
-                        listener.accept(snowflakeEvent);
-                    } catch (Throwable ignored) {
-                    }
-                }
-            }
-        }
-    }
-
-    // ------------------------------------------------------------------------
-    // Lifecycle
-    // ------------------------------------------------------------------------
-    public static void shutdown() {
-        DISRUPTOR.shutdown();
-        LISTENERS.clear();
-        UUID_LISTENERS.clear();
-    }
-
-    public static void reset() {
-        LISTENERS.clear();
-        UUID_LISTENERS.clear();
-    }
-
-    public static Map<Class<?>, CopyOnWriteArrayList<ListenerHandler<?>>> getAllListeners() {
-        return LISTENERS;
-    }
 }

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

@@ -1,48 +0,0 @@
-package org.toop.framework.eventbus;
-
-import org.toop.framework.SnowflakeGenerator;
-import org.toop.framework.eventbus.events.EventType;
-
-import java.util.function.Consumer;
-
-public class ListenerHandler<T extends EventType> {
-    private final long id;
-    private final String name;
-    private final Class<T> clazz;
-    private final Consumer<T> listener;
-
-    public ListenerHandler(long id, String name, Class<T> clazz, Consumer<T> listener) {
-        this.id = id;
-        this.name = name;
-        this.clazz = clazz;
-        this.listener = listener;
-    }
-
-    public ListenerHandler(String name, Class<T> clazz, Consumer<T> listener) {
-        this(SnowflakeGenerator.nextId(), name, clazz, listener);
-    }
-
-    public ListenerHandler(long id, Class<T> clazz, Consumer<T> listener) {
-        this(id, String.valueOf(id), clazz, listener);
-    }
-
-    public ListenerHandler(Class<T> clazz, Consumer<T> listener) {
-        this(SnowflakeGenerator.nextId(), clazz, listener);
-    }
-
-    public long getId() {
-        return id;
-    }
-
-    public Consumer<T> getListener() {
-        return listener;
-    }
-
-    public Class<T> getListenerClass() {
-        return clazz;
-    }
-
-    public String getName() {
-        return name;
-    }
-}

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

@@ -0,0 +1,63 @@
+package org.toop.framework.eventbus.bus;
+
+import org.apache.logging.log4j.Logger;
+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 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;
+    }
+
+    @Override
+    public void subscribe(Subscriber<? extends EventType> subscriber) {
+        eventsHolder.add(subscriber);
+    }
+
+    @Override
+    public void unsubscribe(Subscriber<? extends EventType> subscriber) {
+        eventsHolder.remove(subscriber);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T extends EventType> void post(T event) {
+        Class<T> eventType = (Class<T>) event.getClass();
+        var subs = eventsHolder.get(eventType);
+        if (subs != null) {
+            for (Subscriber<?> subscriber : subs) {
+                Class<T> eventClass = (Class<T>) subscriber.event();
+                Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
+
+                action.accept(eventClass.cast(event));
+            }
+        }
+    }
+
+    @Override
+    public <T extends EventType> void asyncPost(T event) {
+        asyncExecutor.submit(() -> post(event));
+    }
+
+    @Override
+    public void shutdown() {
+        eventsHolder.reset();
+    }
+
+    @Override
+    public void reset() {
+        eventsHolder.reset();
+    }
+
+}

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

@@ -0,0 +1,117 @@
+package org.toop.framework.eventbus.bus;
+
+import com.lmax.disruptor.BusySpinWaitStrategy;
+import com.lmax.disruptor.RingBuffer;
+import com.lmax.disruptor.dsl.Disruptor;
+import com.lmax.disruptor.dsl.ProducerType;
+import org.apache.logging.log4j.Logger;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.store.SubscriberStore;
+
+import java.util.concurrent.ThreadFactory;
+import java.util.function.Consumer;
+
+public class DisruptorEventBus implements EventBus {
+    /** Wrapper used inside the ring buffer. */
+    private static class EventHolder<T> {
+        T event;
+    }
+
+    private final Logger logger;
+    private final SubscriberStore eventsHolder;
+
+    private final Disruptor<EventHolder<? extends EventType>> disruptor;
+    private final RingBuffer<EventHolder<? extends EventType>> ringBuffer;
+
+    public DisruptorEventBus(Logger logger, SubscriberStore eventsHolder) {
+        this.logger = logger;
+        this.eventsHolder = eventsHolder;
+
+        ThreadFactory threadFactory =
+                r -> {
+                    Thread t = new Thread(r, "EventBus-Disruptor");
+                    t.setDaemon(true);
+                    return t;
+                };
+
+        disruptor = getEventHolderDisruptor(threadFactory);
+
+        disruptor.start();
+        this.ringBuffer = disruptor.getRingBuffer();
+    }
+
+    private Disruptor<EventHolder<? extends EventType>> getEventHolderDisruptor(ThreadFactory threadFactory) {
+        int RING_BUFFER_SIZE = 1024 * 64;
+        Disruptor<EventHolder<? extends EventType>> disruptor = new Disruptor<>(
+                EventHolder::new,
+                RING_BUFFER_SIZE,
+                threadFactory,
+                ProducerType.MULTI,
+                new BusySpinWaitStrategy());
+
+        disruptor.handleEventsWith(
+                (holder, _, _) -> {
+                    if (holder.event != null) {
+                        dispatchEvent(holder.event);
+                        holder.event = null;
+                    }
+                });
+        return disruptor;
+    }
+
+    @Override
+    public void subscribe(Subscriber<? extends EventType> listener) {
+        eventsHolder.add(listener);
+    }
+
+    @Override
+    public void unsubscribe(Subscriber<? extends EventType> listener) {
+        eventsHolder.remove(listener);
+    }
+
+    @Override
+    public <T extends EventType> void post(T event) {
+        long seq = ringBuffer.next();
+        try {
+            @SuppressWarnings("unchecked")
+            EventHolder<T> holder = (EventHolder<T>) ringBuffer.get(seq);
+            holder.event = event;
+        } finally {
+            ringBuffer.publish(seq);
+        }
+    }
+
+    @Override
+    public void shutdown() {
+        disruptor.shutdown();
+        eventsHolder.reset();
+    }
+
+    @Override
+    public void reset() {
+        eventsHolder.reset();
+    }
+
+    private <T extends EventType> void dispatchEvent(T event) {
+        var classListeners = eventsHolder.get(event.getClass());
+        if (classListeners != null) {
+            for (Subscriber<?> listener : classListeners) {
+                try {
+                    callListener(listener, event);
+                } catch (Throwable e) {
+                    logger.warn("Exception while handling event: {}", event, e);
+                }
+            }
+        }
+    }
+
+
+    @SuppressWarnings("unchecked")
+    private <T> void callListener(Subscriber<?> subscriber, T event) {
+        Class<T> eventClass = (Class<T>) subscriber.event();
+        Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
+
+        action.accept((EventType) eventClass.cast(event));
+    }
+}

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

@@ -0,0 +1,12 @@
+package org.toop.framework.eventbus.bus;
+
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+
+public interface EventBus {
+    void subscribe(Subscriber<? extends EventType> subscriber);
+    void unsubscribe(Subscriber<? extends EventType> subscriber);
+    <T extends EventType> void post(T event);
+    void shutdown();
+    void reset();
+}

framework/src/main/java/org/toop/framework/eventbus/store/AsyncSubscriberStore.java

@@ -0,0 +1,47 @@
+package org.toop.framework.eventbus.store;
+
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.ConcurrentLinkedQueue;
+
+public class AsyncSubscriberStore implements SubscriberStore {
+    private final ConcurrentHashMap<Class<? extends EventType>, ConcurrentLinkedQueue<Subscriber<? extends EventType>>> queues = new ConcurrentHashMap<>();
+    private final ConcurrentHashMap<Class<? extends EventType>, Subscriber<? extends EventType>[]> snapshots = new ConcurrentHashMap<>();
+
+    @Override
+    public void add(Subscriber<? extends EventType> sub) {
+        queues.computeIfAbsent(sub.event(), _ -> new ConcurrentLinkedQueue<>()).add(sub);
+        rebuildSnapshot(sub.event());
+    }
+
+    @Override
+    public void remove(Subscriber<? extends EventType> sub) {
+        ConcurrentLinkedQueue<Subscriber<?>> queue = queues.get(sub.event());
+        if (queue != null) {
+            queue.remove(sub);
+            rebuildSnapshot(sub.event());
+        }
+    }
+
+    @Override
+    public Subscriber<? extends EventType>[] get(Class<? extends EventType> event) {
+        return snapshots.getOrDefault(event, new Subscriber<?>[0]);
+    }
+
+    @Override
+    public void reset() {
+        queues.clear();
+        snapshots.clear();
+    }
+
+    private void rebuildSnapshot(Class<? extends EventType> event) {
+        ConcurrentLinkedQueue<Subscriber<?>> queue = queues.get(event);
+        if (queue != null) {
+            snapshots.put(event, queue.toArray(new Subscriber<?>[0]));
+        } else {
+            snapshots.put(event, new Subscriber<?>[0]);
+        }
+    }
+}

framework/src/main/java/org/toop/framework/eventbus/store/DefaultSubscriberStore.java

@@ -0,0 +1,73 @@
+package org.toop.framework.eventbus.store;
+
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.subscriber.NamedSubscriber;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+
+import java.util.concurrent.ConcurrentHashMap;
+
+public class DefaultSubscriberStore implements SubscriberStore {
+
+    private static final Subscriber<? extends EventType>[] EMPTY = new Subscriber<?>[0];
+
+    private final ConcurrentHashMap<Class<? extends EventType>, Subscriber<? extends EventType>[]>
+            listeners = new ConcurrentHashMap<>();
+
+    @Override
+    public void add(Subscriber<? extends EventType> sub) {
+        listeners.compute(sub.event(), (_, arr) -> {
+            if (arr == null || arr.length == 0) {
+                return new Subscriber<?>[]{sub};
+            }
+
+            int len = arr.length;
+            Subscriber<?>[] newArr = new Subscriber[len + 1];
+            System.arraycopy(arr, 0, newArr, 0, len);
+            newArr[len] = sub;
+            return newArr;
+        });
+    }
+
+    @Override
+    public void remove(Subscriber<? extends EventType> sub) {
+        listeners.computeIfPresent(sub.event(), (_, arr) -> {
+            int len = arr.length;
+
+            if (len == 1) {
+                return arr[0].equals(sub) ? null : arr;
+            }
+
+            int keep = 0;
+            for (Subscriber<?> s : arr) {
+                if (!s.equals(sub)) keep++;
+            }
+
+            if (keep == len) {
+                return arr;
+            }
+            if (keep == 0) {
+                return null;
+            }
+
+            Subscriber<?>[] newArr = new Subscriber[keep];
+            int i = 0;
+            for (Subscriber<?> s : arr) {
+                if (!s.equals(sub)) {
+                    newArr[i++] = s;
+                }
+            }
+
+            return newArr;
+        });
+    }
+
+    @Override
+    public Subscriber<? extends EventType>[] get(Class<? extends EventType> event) {
+        return listeners.getOrDefault(event, EMPTY);
+    }
+
+    @Override
+    public void reset() {
+        listeners.clear();
+    }
+}

framework/src/main/java/org/toop/framework/eventbus/store/SubscriberStore.java

@@ -0,0 +1,11 @@
+package org.toop.framework.eventbus.store;
+
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+
+public interface SubscriberStore {
+    void add(Subscriber<? extends EventType> subscriber);
+    void remove(Subscriber<? extends EventType> subscriber);
+    Subscriber<? extends EventType>[] get(Class<? extends EventType> event);
+    void reset();
+}

framework/src/main/java/org/toop/framework/eventbus/store/SyncSubscriberStore.java

@@ -0,0 +1,37 @@
+package org.toop.framework.eventbus.store;
+
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+public class SyncSubscriberStore implements SubscriberStore {
+    private final Map<Class<? extends EventType>, List<Subscriber<? extends EventType>>> LISTENERS = new ConcurrentHashMap<>();
+    private static final Subscriber<? extends EventType>[] EMPTY = new Subscriber<?>[0];
+
+    @Override
+    public void add(Subscriber<? extends EventType> sub) {
+        LISTENERS.computeIfAbsent(sub.event(), _ -> new ArrayList<>()).add(sub);
+    }
+
+    @Override
+    public void remove(Subscriber<? extends EventType> sub) {
+        LISTENERS.getOrDefault(sub.event(), new ArrayList<>()).remove(sub);
+        LISTENERS.entrySet().removeIf(entry -> entry.getValue().isEmpty());
+    }
+
+    @Override
+    public Subscriber<? extends EventType>[] get(Class<? extends EventType> event) {
+        List<Subscriber<? extends EventType>> list = LISTENERS.get(event);
+        if (list == null || list.isEmpty()) return EMPTY;
+        return list.toArray(EMPTY);
+    }
+
+    @Override
+    public void reset() {
+        LISTENERS.clear();
+    }
+}

framework/src/main/java/org/toop/framework/eventbus/subscriber/DefaultNamedSubscriber.java

@@ -0,0 +1,8 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+import java.util.function.Consumer;
+
+public record DefaultNamedSubscriber<K extends EventType>(String id, Class<K> event, Consumer<K> handler)
+        implements NamedSubscriber<K> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/DefaultSubscriber.java

@@ -0,0 +1,8 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+import java.util.function.Consumer;
+
+public record DefaultSubscriber<K extends EventType>(Class<K> event, Consumer<K> handler) implements Subscriber<K> {}
+

framework/src/main/java/org/toop/framework/eventbus/subscriber/HasId.java

@@ -0,0 +1,5 @@
+package org.toop.framework.eventbus.subscriber;
+
+public interface HasId<ID> {
+    ID id();
+}

framework/src/main/java/org/toop/framework/eventbus/subscriber/IdSubscriber.java

@@ -0,0 +1,5 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+public interface IdSubscriber<K extends EventType> extends Subscriber<K>, HasId<Long> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/LongIdSubscriber.java

@@ -0,0 +1,8 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+import java.util.function.Consumer;
+
+public record LongIdSubscriber<K extends EventType>(Long id, Class<K> event, Consumer<K> handler)
+        implements IdSubscriber<K> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/NamedSubscriber.java

@@ -0,0 +1,5 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+public interface NamedSubscriber<K extends EventType> extends Subscriber<K>, HasId<String> {}

framework/src/main/java/org/toop/framework/eventbus/subscriber/Subscriber.java

@@ -0,0 +1,10 @@
+package org.toop.framework.eventbus.subscriber;
+
+import org.toop.framework.eventbus.events.EventType;
+
+import java.util.function.Consumer;
+
+public interface Subscriber<K extends EventType> {
+    Class<K> event();
+    Consumer<K> handler();
+}

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

@@ -0,0 +1,112 @@
+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 implements TurnBasedGame {
+	private final int columnSize;
+	private final int rowSize;
+
+	protected PlayResult state;
+
+    private Player[] players;
+
+	// long is 64 bits. Every game has a limit of 64 cells maximum.
+	private final long[] playerBitboard;
+	private int currentTurn = 0;
+	private final int playerCount;
+
+	public BitboardGame(int columnSize, int rowSize, int playerCount) {
+		this.columnSize = columnSize;
+		this.rowSize = rowSize;
+        this.playerCount = playerCount;
+		this.state = new PlayResult(GameState.NORMAL, -1);
+
+		this.playerBitboard = new long[playerCount];
+
+		Arrays.fill(playerBitboard, 0L);
+	}
+
+    @Override
+    public void init(Player[] players) {
+        this.players = players;
+
+        Arrays.fill(playerBitboard, 0L);
+    }
+
+	public BitboardGame(BitboardGame other) {
+		this.columnSize = other.columnSize;
+		this.rowSize = other.rowSize;
+        this.playerCount = other.playerCount;
+		this.state = other.state;
+
+		this.playerBitboard = other.playerBitboard.clone();
+		this.currentTurn = other.currentTurn;
+        this.players = 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() {
+		return this.columnSize;
+	}
+
+	public int getRowSize() {
+		return this.rowSize;
+	}
+
+	public long getPlayerBitboard(int player) {
+		return this.playerBitboard[player];
+	}
+
+	public void setPlayerBitboard(int player, long bitboard) {
+		this.playerBitboard[player] = bitboard;
+	}
+
+	public int getPlayerCount() {
+		return playerBitboard.length;
+	}
+
+	public int getCurrentTurn() {
+		return getCurrentPlayerIndex();
+	}
+
+    public Player getPlayer(int index) {return players[index];}
+
+	public int getCurrentPlayerIndex() {
+        return currentTurn % playerBitboard.length;
+	}
+
+	public int getNextPlayer() {
+		return (currentTurn + 1) % playerBitboard.length;
+	}
+
+    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
+    public long[] getBoard() {return this.playerBitboard;}
+
+	public void nextTurn() {
+        currentTurn++;
+	}
+}

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;
@@ -8,26 +8,24 @@ import org.toop.framework.gameFramework.view.GUIEvents;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
+import java.util.function.Consumer;
+
 /**
  * Handles local turn-based game logic at a fixed update rate.
  * <p>
  * 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 {
 
-    /** All players participating in the game. */
-    private final Player<T>[] players;
 
     /**
      * Creates a fixed-rate behaviour for a local turn-based game.
      *
      * @param game    the game instance
-     * @param players the list of players in turn order
      */
-    public LocalFixedRateThreadBehaviour(T game, Player<T>[] players) {
+    public LocalFixedRateThreadBehaviour(TurnBasedGame game) {
         super(game);
-        this.players = players;
     }
 
     /** Starts the game loop thread if not already running. */
@@ -52,7 +50,7 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
      */
     @Override
     public void run() {
-        final int UPS = 60;
+        final int UPS = 1;
         final long UPDATE_INTERVAL = 1_000_000_000L / UPS;
         long nextUpdate = System.nanoTime();
 
@@ -61,10 +59,11 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
             if (now >= nextUpdate) {
                 nextUpdate += UPDATE_INTERVAL;
 
-                Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
-                int move = currentPlayer.getMove(game.deepCopy());
+                Player currentPlayer = game.getPlayer(game.getCurrentTurn());
+                long move = currentPlayer.getMove(game.deepCopy());
                 PlayResult result = game.play(move);
-                new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+
+                updateUI();
 
                 GameState state = result.state();
                 switch (state) {

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;
@@ -8,21 +8,22 @@ import org.toop.framework.gameFramework.GameState;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 import org.toop.framework.gameFramework.model.player.Player;
 
+import java.util.function.Consumer;
+
 /**
  * Handles local turn-based game logic in its own thread.
  * <p>
  * 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
-     * @param players the list of players in turn order
      */
-    public LocalThreadBehaviour(T game, Player<T>[] players) {
+    public LocalThreadBehaviour(TurnBasedGame game) {
         super(game);
     }
 
@@ -47,10 +48,11 @@ public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractTh
     @Override
     public void run() {
         while (isRunning.get()) {
-            Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
-            int move = currentPlayer.getMove(game.deepCopy());
+            Player currentPlayer = game.getPlayer(game.getCurrentTurn());
+            long move = currentPlayer.getMove(game.deepCopy());
             PlayResult result = game.play(move);
-            new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+
+            updateUI();
 
             GameState state = result.state();
             switch (state) {

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

@@ -1,14 +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.AbstractGame;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.networking.events.NetworkEvents;
-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.
@@ -16,24 +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 {
 
-    /** The local player controlled by this client. */
-    private final Player<T> mainPlayer;
-    private final int playerTurn;
+    private ExecutorService moveExecutor = Executors.newSingleThreadExecutor();
 
     /**
      * Creates behaviour and sets the first local player
      * (non-online player) from the given array.
      */
-    public OnlineThreadBehaviour(T game, Player<T>[] players) {
+    public OnlineThreadBehaviour(TurnBasedGame game) {
         super(game);
-        this.playerTurn = getFirstNotOnlinePlayer(players);
-        this.mainPlayer = players[this.playerTurn];
     }
 
     /** 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;
@@ -59,33 +56,53 @@ public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractT
      * Sends the generated move back to the server.
      */
     @Override
-    public void onYourTurn(NetworkEvents.YourTurnResponse event) {
-        if (!isRunning.get()) return;
-        int move = mainPlayer.getMove(game.deepCopy());
-        new EventFlow().addPostEvent(NetworkEvents.SendMove.class, event.clientId(), (short) move).postEvent();
+    public void onYourTurn(long clientId) {
+        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);
     }
 
     /**
      * Handles a move received from the server for any player.
      * Updates the game state and triggers a UI refresh.
      */
-    @Override
-    public void onMoveReceived(NetworkEvents.GameMoveResponse event) {
+    public void onMoveReceived(long move) {
         if (!isRunning.get()) return;
-        game.play(Integer.parseInt(event.move()));
-        new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+        game.play(move);
+
+        updateUI();
     }
 
     /**
      * Handles the end of the game as notified by the server.
      * Updates the UI to show a win or draw result for the local player.
      */
-    @Override
-    public void gameFinished(NetworkEvents.GameResultResponse event) {
-        switch(event.condition().toUpperCase()){
-            case "WIN" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, true, playerTurn).postEvent();
-            case "DRAW" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, false, AbstractGame.EMPTY).postEvent();
-            case "LOSS" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, true, (playerTurn + 1)%2).postEvent();
+    public void gameFinished(String condition) {
+        switch(condition.toUpperCase()){
+            case "WIN", "LOSS" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, true, game.getWinner()).postEvent();
+            case "DRAW" -> new EventFlow().addPostEvent(GUIEvents.GameEnded.class, false, -1).postEvent();
             default -> {
                 logger.error("Invalid condition");
                 throw new RuntimeException("Unknown condition");

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

@@ -1,8 +1,6 @@
-package org.toop.game.gameThreads;
+package org.toop.framework.game.gameThreads;
 
-import org.toop.framework.gameFramework.model.game.AbstractGame;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.framework.gameFramework.model.player.AbstractPlayer;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 /**
  * Online thread behaviour that adds a fixed delay before processing
@@ -16,11 +14,10 @@ public class OnlineWithSleepThreadBehaviour extends OnlineThreadBehaviour {
     /**
      * Creates the behaviour and forwards the players to the base class.
      *
-     * @param game    the online-capable turn-based game
-     * @param players the list of local and remote players
+     * @param game the online-capable turn-based game
      */
-    public OnlineWithSleepThreadBehaviour(AbstractGame game, AbstractPlayer[] players) {
-        super(game, players);
+    public OnlineWithSleepThreadBehaviour(TurnBasedGame game) {
+        super(game);
     }
 
     /**
@@ -29,14 +26,14 @@ public class OnlineWithSleepThreadBehaviour extends OnlineThreadBehaviour {
      * @param event the network event indicating it's this client's turn
      */
     @Override
-    public void onYourTurn(NetworkEvents.YourTurnResponse event) {
+    public void onYourTurn(long clientId) {
 
         try {
-            Thread.sleep(1000);
+            Thread.sleep(50);
         } catch (InterruptedException e) {
             e.printStackTrace();
         }
 
-        super.onYourTurn(event);
+        super.onYourTurn(clientId);
     }
 }

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

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

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

@@ -0,0 +1,371 @@
+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;
+        }
+    }
+
+	@Override
+	public float rateMove(long move) {
+		final long corners = 0x8100000000000081L;
+
+		if ((move & corners) != 0L) {
+			return 0.4f;
+		}
+
+		final long xSquares = 0x0042000000004200L;
+
+		if ((move & xSquares) != 0) {
+			return -0.4f;
+		}
+
+		final long cSquares = 0x4281000000008142L;
+
+		if ((move & cSquares) != 0) {
+			return -0.1f;
+		}
+
+		return 0.0f;
+	}
+
+	@Override
+	public long heuristicMove(long legalMoves) {
+		long bestMove = 0L;
+		float bestMoveRate = Float.NEGATIVE_INFINITY;
+
+		while (legalMoves != 0L) {
+			final long move = legalMoves & -legalMoves;
+			final float moveRate = rateMove(move);
+
+			if (moveRate > bestMoveRate) {
+				bestMove = move;
+				bestMoveRate = moveRate;
+			}
+
+			legalMoves &= ~move;
+		}
+
+		return bestMove;
+	}
+}

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

@@ -0,0 +1,123 @@
+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.framework.game.BitboardGame;
+
+public class BitboardTicTacToe extends BitboardGame {
+	private final long[] winningLines = {
+		0b111000000L, // top row
+		0b000111000L, // middle row
+		0b000000111L, // bottom row
+		0b100100100L, // left column
+		0b010010010L, // middle column
+		0b001001001L, // right column
+		0b100010001L, // diagonal
+		0b001010100L  // anti-diagonal
+	};
+
+	public BitboardTicTacToe() {
+		super(3, 3, 2);
+	}
+
+	@Override
+	public void init(Player[] players) {
+		super.init(players);
+	}
+
+    public BitboardTicTacToe(BitboardTicTacToe other) {
+        super(other);
+    }
+
+    public long getLegalMoves() {
+		final long xBitboard = getPlayerBitboard(0);
+		final long oBitboard = getPlayerBitboard(1);
+
+		final long taken = (xBitboard | oBitboard);
+		return (~taken) & 0x1ffL;
+	}
+
+    public int getWinner(){
+        return getCurrentPlayerIndex();
+    }
+
+	public PlayResult play(long move) {
+        // Player loses if move is invalid
+        if ((move & getLegalMoves()) == 0 || Long.bitCount(move) != 1){
+            state = new PlayResult(GameState.WIN, getNextPlayer());
+			return state;
+        }
+
+        // Move is legal, make move
+		long playerBitboard = getPlayerBitboard(getCurrentPlayerIndex());
+		playerBitboard |= move;
+
+		setPlayerBitboard(getCurrentPlayerIndex(), playerBitboard);
+
+        // Check if current player won
+        if (checkWin(playerBitboard)) {
+			state = new PlayResult(GameState.WIN, getCurrentPlayerIndex());
+            return state;
+        }
+
+        // Proceed to next turn
+        nextTurn();
+
+
+        // Check for early draw
+		if (getLegalMoves() == 0L || checkEarlyDraw()) {
+			state = new PlayResult(GameState.DRAW, -1);
+			return state;
+		}
+
+        // Nothing weird happened, continue on as normal
+		state = new PlayResult(GameState.NORMAL, -1);
+		return state;
+	}
+
+	private boolean checkWin(long board) {
+		for (final long line : winningLines) {
+			if ((board & line) == line) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
+	private boolean checkEarlyDraw() {
+		final long xBitboard = getPlayerBitboard(0);
+		final long oBitboard = getPlayerBitboard(1);
+
+		final long taken = (xBitboard | oBitboard);
+		final long empty = (~taken) & 0x1FFL;
+
+		for (final long line : winningLines) {
+			if (((line & xBitboard) != 0 && (line & oBitboard) != 0)) {
+				continue;
+			}
+
+			if ((line & empty) != 0) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+    @Override
+    public BitboardTicTacToe deepCopy() {
+        return new BitboardTicTacToe(this);
+    }
+
+	@Override
+	public float rateMove(long move) {
+		return 0.0f;
+	}
+
+	@Override
+	public long heuristicMove(long legalMoves) {
+		return legalMoves;
+	}
+}

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

@@ -1,8 +1,6 @@
-package org.toop.game.players;
+package org.toop.framework.game.players;
 
-import org.toop.framework.gameFramework.model.player.AbstractAI;
-import org.toop.framework.gameFramework.model.player.AbstractPlayer;
-import org.toop.framework.gameFramework.model.player.MoveProvider;
+import org.toop.framework.gameFramework.model.player.*;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
 /**
@@ -14,21 +12,26 @@ 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 MoveProvider<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(MoveProvider<T> ai, String name) {
+    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>
@@ -41,7 +44,21 @@ 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 int getMove(T gameCopy) {
+    protected long determineMove(TurnBasedGame gameCopy) {
         return ai.getMove(gameCopy);
     }
+
+    /**
+     * Creates a deep copy of this AI player.
+     *
+     * @return a copy of this player
+     */
+    @Override
+    public ArtificialPlayer deepCopy() {
+        return new ArtificialPlayer(this);
+    }
+
+    public AI getAi() {
+        return ai;
+    }
 }

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

@@ -0,0 +1,108 @@
+package org.toop.framework.game.players;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AbstractPlayer;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+/**
+ * Represents a local player who provides moves manually.
+ *
+ * @param <T> the type of turn-based game
+ */
+public class LocalPlayer extends AbstractPlayer {
+
+    private CompletableFuture<Long> LastMove = new CompletableFuture<>();
+
+    /**
+     * Creates a new local player with the given name.
+     *
+     * @param name the player's name
+     */
+    public LocalPlayer(String name) {
+        super(name);
+    }
+
+    /**
+     * Creates a copy of another local player.
+     *
+     * @param other the player to copy
+     */
+    public LocalPlayer(LocalPlayer other) {
+        super(other);
+        this.LastMove = other.LastMove;
+    }
+
+    /**
+     * Waits for and returns the player's next legal move.
+     *
+     * @param gameCopy a copy of the current game
+     * @return the chosen move
+     */
+    @Override
+    protected long determineMove(TurnBasedGame gameCopy) {
+        long legalMoves = gameCopy.getLegalMoves();
+        long move;
+
+        try {
+            do {
+                move = getLastMove();
+                IO.println("GETTING MOVE");
+            } while ((legalMoves & move) == 0);
+            return move;
+        } catch (Exception e) {
+            IO.println(e);
+        }
+        return -1;
+    }
+
+    /**
+     * Sets the player's last move.
+     *
+     * @param move the move to set
+     */
+    public void setLastMove(long move) {
+        LastMove.complete(move);
+    }
+
+    /**
+     * Waits for the next move from the player.
+     *
+     * @return the chosen move or 0 if interrupted
+     */
+    private long getLastMove() {
+        LastMove = new CompletableFuture<>(); // Reset the future
+        try {
+            return LastMove.get();
+        } catch (ExecutionException | InterruptedException e) {
+            return 0;
+        }
+    }
+
+    /**
+     * Creates a deep copy of this local player.
+     *
+     * @return a copy of this player
+     */
+    @Override
+    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

@@ -0,0 +1,51 @@
+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;
+
+/**
+ * Represents a player that participates online.
+ *
+ * @param <T> the type of turn-based game
+ */
+public class OnlinePlayer extends AbstractPlayer {
+
+    /**
+     * Creates a new online player with the given name.
+     *
+     * @param name the name of the player
+     */
+    public OnlinePlayer(String name) {
+        super(name);
+    }
+
+    /**
+     * Creates a copy of another online player.
+     *
+     * @param other the player to copy
+     */
+    public OnlinePlayer(OnlinePlayer other) {
+        super(other);
+    }
+
+    /**
+     * {@inheritDoc}
+     * <p>
+     * This method is not supported for online players.
+     *
+     * @throws UnsupportedOperationException always
+     */
+    @Override
+    protected long determineMove(TurnBasedGame gameCopy) {
+        throw new UnsupportedOperationException("An online player does not support determining move");
+    }
+
+    /**
+     * {@inheritDoc}
+     */
+    @Override
+    public Player deepCopy() {
+        return new OnlinePlayer(this);
+    }
+}

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

@@ -0,0 +1,36 @@
+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<>();
+
+        client.send("SVR GAME YOURTURN {TURNMESSAGE: \"<bericht voor deze beurt>\"}");
+        return lastMove.join();
+    }
+}