Added find functionality

.github/workflows/checks.yaml

@@ -1,42 +1,42 @@
-#name: Checks
+name: Checks
 
-#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
+on:
+  push:
+    branches:
+      - 'main'
+  pull_request:
+    branches:
+      - 'main'
 
-#  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
+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

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

@@ -1,6 +1,13 @@
 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;
 
 public final class Main {
     static void main(String[] args) {

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

@@ -2,7 +2,6 @@ package org.toop.app;
 
 import javafx.application.Platform;
 import javafx.scene.input.KeyCode;
-import javafx.scene.input.KeyCodeCombination;
 import javafx.scene.input.KeyEvent;
 
 import org.toop.app.widget.Primitive;
@@ -15,8 +14,6 @@ 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.eventbus.GlobalEventBus;
-import org.toop.game.machinelearning.NeuralNetwork;
 import org.toop.framework.networking.NetworkingClientEventListener;
 import org.toop.framework.networking.NetworkingClientManager;
 import org.toop.framework.resource.ResourceLoader;
@@ -35,9 +32,6 @@ 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;
@@ -51,7 +45,7 @@ public final class App extends Application {
 	}
 
 	@Override
-	public void start(Stage stage) {
+	public void start(Stage stage) throws Exception {
 		// Start loading localization
 		ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/localization"));
 		ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/style"));
@@ -69,8 +63,8 @@ public final class App extends Application {
 
 		scene.getRoot();
 
-        stage.setMinWidth(1200);
-        stage.setMinHeight(800);
+        stage.setMinWidth(1080);
+        stage.setMinHeight(720);
 		stage.setOnCloseRequest(event -> {
 			event.consume();
 			quit();
@@ -112,61 +106,40 @@ 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");
 
-		ExecutorService executor = Executors.newSingleThreadExecutor();
-		try {
-			executor.submit(
-				() -> ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets")
-			));
-		} finally {
-			executor.shutdown();
-		}
+		// Start loading assets
+		new Thread(() -> ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets")))
+				.start();
 
 		stage.show();
 
-        //startML();
 	}
 
-    private void startML() {
-        NeuralNetwork nn = new NeuralNetwork();
-        nn.init();
-    }
-
 	private void setKeybinds(StackPane root) {
 		root.addEventHandler(KeyEvent.KEY_PRESSED,event -> {
 			if (event.getCode() == KeyCode.ESCAPE) {
 				escapePopup();
 			}
 		});
-        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()) {
@@ -181,14 +154,8 @@ public final class App extends Application {
 
 	private void setOnLoadingSuccess(LoadingWidget loading) {
 		loading.setOnSuccess(() -> {
-
-            try {
-                initSystems();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
-
-            AppSettings.applyMusicVolumeSettings();
+			initSystems();
+			AppSettings.applyMusicVolumeSettings();
 			new EventFlow().addPostEvent(new AudioEvents.StartBackgroundMusic()).postEvent();
             loading.hide();
 			WidgetContainer.add(Pos.CENTER, new MainView());
@@ -205,55 +172,36 @@ public final class App extends Application {
 		});
 	}
 
-	private void initSystems() throws InterruptedException { // TODO Move to better place
+	private void initSystems() { // TODO Move to better place
+		new Thread(() -> new NetworkingClientEventListener(new NetworkingClientManager())).start();
 
-		final int THREAD_COUNT = 2;
-		CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
+		new Thread(() -> {
+			MusicManager<MusicAsset> musicManager =
+					new MusicManager<>(ResourceManager.getAllOfTypeAndRemoveWrapper(MusicAsset.class), true);
 
-		@SuppressWarnings("resource")
-		ExecutorService threads = Executors.newFixedThreadPool(THREAD_COUNT);
+			SoundEffectManager<SoundEffectAsset> soundEffectManager =
+					new SoundEffectManager<>(ResourceManager.getAllOfType(SoundEffectAsset.class));
 
-		try {
+			AudioVolumeManager audioVolumeManager = new AudioVolumeManager()
+					.registerManager(VolumeControl.MASTERVOLUME, musicManager)
+					.registerManager(VolumeControl.MASTERVOLUME, soundEffectManager)
+					.registerManager(VolumeControl.FX, soundEffectManager)
+					.registerManager(VolumeControl.MUSIC, musicManager);
 
-			threads.submit(() -> {
-				new NetworkingClientEventListener(
-						GlobalEventBus.get(),
-						new NetworkingClientManager(GlobalEventBus.get()));
+			new AudioEventListener<>(
+					musicManager,
+					soundEffectManager,
+					audioVolumeManager
+			).initListeners("medium-button-click.wav");
 
-				latch.countDown();
-			});
+		}).start();
 
-			threads.submit(() -> {
-				MusicManager<MusicAsset> musicManager =
-						new MusicManager<>(
-								GlobalEventBus.get(),
-								ResourceManager.getAllOfTypeAndRemoveWrapper(MusicAsset.class),
-								true
-						);
-
-				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();
-		}
+		// Threads must be ready, before continue, TODO use latch instead
+        try {
+            Thread.sleep(200);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
     }
 
 	public static void quit() {

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

@@ -2,7 +2,9 @@ package org.toop.app;
 
 import javafx.application.Platform;
 import javafx.geometry.Pos;
-import org.toop.app.gameControllers.*;
+import org.toop.app.gameControllers.AbstractGameController;
+import org.toop.app.gameControllers.ReversiController;
+import org.toop.app.gameControllers.TicTacToeController;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.WidgetContainer;
 import org.toop.app.widget.complex.LoadingWidget;
@@ -11,17 +13,15 @@ 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.gameFramework.controller.GameController;
-import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.framework.networking.clients.TournamentNetworkingClient;
 import org.toop.framework.networking.events.NetworkEvents;
 import org.toop.framework.networking.types.NetworkingConnector;
-import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
 import org.toop.game.players.ArtificialPlayer;
 import org.toop.game.players.OnlinePlayer;
-import org.toop.game.players.ai.RandomAI;
+import org.toop.game.games.reversi.ReversiAIR;
+import org.toop.game.games.reversi.ReversiR;
+import org.toop.game.games.tictactoe.TicTacToeAIR;
 import org.toop.local.AppContext;
 
 import java.util.List;
@@ -32,7 +32,6 @@ 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 String user = "";
 	private long clientId = -1;
 
@@ -42,7 +41,7 @@ public final class Server {
 	private ServerView primary;
 	private boolean isPolling = true;
 
-    private GameController gameController;
+    private AbstractGameController<?> gameController;
 
     private final AtomicBoolean isSingleGame = new AtomicBoolean(false);
 
@@ -89,11 +88,11 @@ public final class Server {
                 Primitive.text("connecting"), 0, 0, reconnectAttempts, true, true
         );
 
-		WidgetContainer.getCurrentView().transitionNextCustom(loading, "disconnect", this::disconnect);
+		WidgetContainer.getCurrentView().transitionNext(loading);
 
 		var a = new EventFlow()
 			.addPostEvent(NetworkEvents.StartClient.class,
-				new TournamentNetworkingClient(GlobalEventBus.get()),
+				new TournamentNetworkingClient(),
 				new NetworkingConnector(ip, parsedPort, reconnectAttempts, 1, TimeUnit.SECONDS)
 			);
 
@@ -106,9 +105,8 @@ public final class Server {
             );
         });
 
-		a.onResponse(NetworkEvents.CreatedIdForClient.class, e -> clientId = e.clientId(), true);
-
 		a.onResponse(NetworkEvents.StartClientResponse.class, e -> {
+
 			if (!e.successful()) {
 				return;
 			}
@@ -120,6 +118,7 @@ public final class Server {
 			a.unsubscribe("startclient");
 
 			this.user = user;
+			clientId = e.clientId();
 
 			new EventFlow().addPostEvent(new NetworkEvents.SendLogin(clientId, user)).postEvent();
 
@@ -130,24 +129,21 @@ public final class Server {
 
 		}, false, "startclient")
 				.listen(
-						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"
-				)
+                        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"
+                )
 				.postEvent();
 
 		a.listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false, "challenge")
@@ -201,31 +197,26 @@ public final class Server {
             information.players[0].computerThinkTime = 1;
             information.players[1].name = response.opponent();
 
-            /*switch (type){
+            Player[] players = new Player[2];
+
+            players[(myTurn + 1) % 2] = new OnlinePlayer<ReversiR>(response.opponent());
+
+            switch (type){
                 case TICTACTOE ->{
                     players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(9), user);
                 }
                 case REVERSI ->{
                     players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
                 }
-            }*/
-
-
+            }
 
             switch (type) {
                 case TICTACTOE ->{
-                        Player<BitboardTicTacToe>[] players = new Player[2];
-                        players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
-                        players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), user);
-                        gameController = new TicTacToeBitController(players);
+                        gameController = new TicTacToeController(players, false);
                 }
-                case REVERSI -> {
-                    Player<BitboardReversi>[] players = new Player[2];
-                    players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
-                    players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), user);
-                    gameController = new ReversiBitController(players);}
+                case REVERSI ->
+                        gameController = new ReversiController(players, false);
                 default -> new ErrorPopup("Unsupported game type.");
-
             }
 
             if (gameController != null){

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

@@ -1,247 +0,0 @@
-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<T extends TurnBasedGame<T>> implements GameCanvas<T> {
-	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

@@ -0,0 +1,17 @@
+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.TurnBasedGame;
+import org.toop.framework.gameFramework.model.game.AbstractGame;
 
 public interface DrawPlayerHover {
-    void drawPlayerHover(int player, int move, TurnBasedGame game);
+    void drawPlayerHover(int player, int move, AbstractGame game);
 }

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

@@ -1,8 +1,237 @@
 package org.toop.app.canvas;
 
+import javafx.animation.KeyFrame;
+import javafx.animation.Timeline;
 import javafx.scene.canvas.Canvas;
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+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;
 
-public interface GameCanvas<T extends TurnBasedGame<T>> extends GameDrawer<T>{
-    Canvas getCanvas();
-}
+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;
+	}
+}

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

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

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

@@ -1,42 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-import org.toop.app.App;
-import org.toop.game.games.reversi.BitboardReversi;
-
-import java.util.Arrays;
-import java.util.function.Consumer;
-
-public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> {
-    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;
-                }
-            }
-        });
-    }
-
-    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(BitboardReversi gameCopy) {
-        clearAll();
-        long[] board = gameCopy.getBoard();
-        loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
-        loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
-    }
-}

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

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

@@ -1,63 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-import org.toop.app.App;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
-
-import java.util.Arrays;
-import java.util.function.Consumer;
-
-public class TicTacToeBitCanvas extends BitGameCanvas<BitboardTicTacToe>{
-    public TicTacToeBitCanvas() {
-        super(
-                Color.GRAY,
-                Color.TRANSPARENT,
-                (App.getHeight() / 4) * 3,
-                (App.getHeight() / 4) * 3,
-                3,
-                3,
-                30,
-                false
-        );
-    }
-
-    @Override
-    public void redraw(BitboardTicTacToe 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

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

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

@@ -1,140 +0,0 @@
-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.widget.WidgetContainer;
-import org.toop.app.widget.view.GameView;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.eventbus.GlobalEventBus;
-import org.toop.framework.gameFramework.controller.GameController;
-import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.framework.gameFramework.view.GUIEvents;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.players.LocalPlayer;
-
-public class GenericGameController<T extends TurnBasedGame<T>> 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<T> canvas;
-
-    protected final TurnBasedGame<T> game;       // Reference to game instance
-    private final ThreadBehaviour gameThreadBehaviour;
-
-    // TODO: Change gameType to automatically happen with either dependency injection or something else.
-    public GenericGameController(GameCanvas<T> canvas, T game, ThreadBehaviour gameThreadBehaviour, String gameType) {
-        logger.info("Creating: " + this.getClass());
-
-        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
-        eventFlow
-                .listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
-                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setLastMove(event.move());}}, false);
-    }
-
-    public void start(){
-        logger.info("Starting GameManager");
-        updateUI();
-        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();
-    }
-
-    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("Game Finished");
-        String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
-        gameView.gameOver(event.winOrTie(), name);
-        stop();
-    }
-
-    public Player<T> getPlayer(int player){
-        if (player < 0 || player >= 2){ // TODO: Make game turn player count
-            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() {
-        canvas.redraw(game.deepCopy());
-    }
-}

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

@@ -1,22 +0,0 @@
-package org.toop.app.gameControllers;
-
-import org.toop.app.canvas.ReversiBitCanvas;
-import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.gameThreads.LocalThreadBehaviour;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.players.OnlinePlayer;
-
-public class ReversiBitController extends GenericGameController<BitboardReversi> {
-    public ReversiBitController(Player<BitboardReversi>[] players) {
-        BitboardReversi game = new BitboardReversi(players);
-        ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
-        for (Player<BitboardReversi> player : players) {
-            if (player instanceof OnlinePlayer<BitboardReversi>){
-                thread = new OnlineThreadBehaviour<>(game);
-            }
-        }
-        super(new ReversiBitCanvas(), game, thread, "Reversi");
-    }
-}

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

@@ -0,0 +1,138 @@
+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(), 'R');
+    }
+
+    @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

@@ -1,23 +0,0 @@
-package org.toop.app.gameControllers;
-
-import org.toop.app.canvas.TicTacToeBitCanvas;
-import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.gameThreads.LocalFixedRateThreadBehaviour;
-import org.toop.game.gameThreads.LocalThreadBehaviour;
-import org.toop.game.gameThreads.OnlineThreadBehaviour;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
-import org.toop.game.players.OnlinePlayer;
-
-public class TicTacToeBitController extends GenericGameController<BitboardTicTacToe> {
-    public TicTacToeBitController(Player<BitboardTicTacToe>[] players) {
-        BitboardTicTacToe game = new BitboardTicTacToe(players);
-        ThreadBehaviour thread = new LocalThreadBehaviour<>(game);
-        for (Player<BitboardTicTacToe> player : players) {
-            if (player instanceof OnlinePlayer<BitboardTicTacToe>){
-                thread = new OnlineThreadBehaviour<>(game);
-            }
-        }
-        super(new TicTacToeBitCanvas(), game, thread , "TicTacToe");
-    }
-}

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

@@ -0,0 +1,63 @@
+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(), 'T');
+        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,6 +6,7 @@ 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;

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

@@ -1,5 +1,6 @@
 package org.toop.app.widget;
 
+import javafx.collections.ObservableList;
 import javafx.scene.Node;
 import org.toop.app.widget.complex.PopupWidget;
 import org.toop.app.widget.complex.ViewWidget;

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

@@ -3,6 +3,7 @@ package org.toop.app.widget.complex;
 import javafx.application.Platform;
 import javafx.geometry.Pos;
 import javafx.scene.Node;
+import javafx.scene.control.Control;
 import javafx.scene.control.ProgressBar;
 import javafx.scene.control.ProgressIndicator;
 import javafx.scene.layout.VBox;

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

@@ -23,7 +23,7 @@ public class PlayerInfoWidget {
 	}
 
 	private ToggleWidget buildToggle() {
-        return new ToggleWidget(
+		return new ToggleWidget(
 			"computer", "player",
 			information.isHuman,
 			isHuman -> {
@@ -37,14 +37,7 @@ public class PlayerInfoWidget {
 	}
 
 	private Node buildContent() {
-
         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",
@@ -52,7 +45,7 @@ public class PlayerInfoWidget {
                     newName -> information.name = newName
             );
 
-            return Primitive.vbox(spacer,nameInput.getNode());
+            return nameInput.getNode();
         } else {
             var AIBox = Primitive.vbox(
                     makeAIButton(0, 1, "zwartepiet"),

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.get().post(new AudioEvents.SkipMusic());
+			GlobalEventBus.post(new AudioEvents.SkipMusic());
 		});
 
 		pauseButton.setOnAction(event -> {
-			GlobalEventBus.get().post(new AudioEvents.PauseMusic());
+			GlobalEventBus.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.get().post(new AudioEvents.PreviousMusic());
+			GlobalEventBus.post(new AudioEvents.PreviousMusic());
 		});
 
 		HBox control = new HBox(10, previousButton, pauseButton, skipButton);

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

@@ -1,48 +1,31 @@
 package org.toop.app.widget.popup;
 
 import javafx.geometry.Pos;
-import javafx.scene.Node;
+import org.toop.app.App;
 import org.toop.app.widget.Primitive;
-import org.toop.app.widget.Widget;
 import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.ConfirmWidget;
 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<>();
+        var con = Primitive.button("Continue", this::hide, false); // TODO, localize
 
-        nodes.add(Primitive.button("Continue", this::hide, false)); // TODO, localize
+        var qui = Primitive.button("quit", () -> {
+            hide();
+            WidgetContainer.add(Pos.CENTER, new QuitPopup());
+        });
 
-        if (!(currentView.getClass().isAssignableFrom(OptionsView.class))) {
+        if (!(WidgetContainer.getCurrentView().getClass().isAssignableFrom(OptionsView.class))) {
             var opt = Primitive.button("options", () -> {
                 hide();
                 WidgetContainer.getCurrentView().transitionNext(new OptionsView());
             });
-            nodes.add(opt);
+            add(Pos.CENTER, Primitive.vbox(con, opt, qui));
+        } else {
+            add(Pos.CENTER, Primitive.vbox(con, qui));
         }
 
-        if (currentView.getClass().isAssignableFrom(GameView.class)) {
-            Widget tut = AppContext.currentTutorial();
-            if (tut != null) {
-                nodes.add(Primitive.button("tutorialstring", () -> {
-                    WidgetContainer.getCurrentView().add(Pos.CENTER, tut);
-                }));
-            }
-        }
-
-        nodes.add(Primitive.button("quit", () -> {
-            hide();
-            WidgetContainer.add(Pos.CENTER, new QuitPopup());
-        }));
-
-        add(Pos.CENTER, Primitive.vbox(nodes.toArray(new Node[0])));
-
     }
 }

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

@@ -2,6 +2,7 @@ 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/tutorial/BaseTutorialWidget.java

@@ -7,6 +7,7 @@ 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;
@@ -58,6 +59,8 @@ 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/view/GameView.java

@@ -26,6 +26,7 @@ public final class GameView extends ViewWidget {
     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;
@@ -60,16 +61,15 @@ public final class GameView extends ViewWidget {
 			chatInput = null;
 		}
 
-        switch (gameType) {
+        switch(gameType) {
             case "TicTacToe":
-                AppContext.setCurrentTutorial(new TicTacToeTutorialWidget(() -> {}));
-                break;
+                this.tutorialButton = Primitive.button("tutorialstring", () -> new TicTacToeTutorialWidget(() -> {})); break;
             case "Reversi":
-                AppContext.setCurrentTutorial(new ReversiTutorialWidget(() -> {}));
-                break;
+                this.tutorialButton = Primitive.button("tutorialstring", () -> new ReversiTutorialWidget(() -> {})); break;
             case "Connect4":
-                AppContext.setCurrentTutorial(new Connect4TutorialWidget(() -> {}));
-                break;
+                this.tutorialButton = Primitive.button("tutorialstring", () -> new Connect4TutorialWidget(() -> {})); break;
+            default:
+                this.tutorialButton = null; break;
         }
 
 		setupLayout();
@@ -92,6 +92,10 @@ 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, char GameType) {

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

@@ -2,21 +2,20 @@ package org.toop.app.widget.view;
 
 import javafx.application.Platform;
 import org.toop.app.GameInformation;
-import org.toop.app.gameControllers.ReversiBitController;
-import org.toop.app.gameControllers.TicTacToeBitController;
-import org.toop.framework.gameFramework.controller.GameController;
+import org.toop.app.gameControllers.AbstractGameController;
+import org.toop.app.gameControllers.ReversiController;
+import org.toop.app.gameControllers.TicTacToeController;
 import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.game.games.tictactoe.TicTacToeAIRSleep;
 import org.toop.game.players.ArtificialPlayer;
 import org.toop.game.players.LocalPlayer;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.PlayerInfoWidget;
 import org.toop.app.widget.complex.ViewWidget;
 import org.toop.app.widget.popup.ErrorPopup;
+import org.toop.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.RandomAI;
 import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
@@ -27,7 +26,7 @@ import org.toop.local.AppSettings;
 public class LocalMultiplayerView extends ViewWidget {
 	private final GameInformation information;
 
-    private GameController gameController;
+    private AbstractGameController<?> gameController;
 
 	public LocalMultiplayerView(GameInformation.Type type) {
 		this(new GameInformation(type));
@@ -46,7 +45,7 @@ public class LocalMultiplayerView extends ViewWidget {
 				}
 			}
 
-            // TODO: Fix this temporary ass way of setting the players
+            // TODO: Fix this temporary ass way of setting the players (Only works for TicTacToe)
             Player[] players = new Player[2];
 
 			switch (information.type) {
@@ -54,27 +53,27 @@ public class LocalMultiplayerView extends ViewWidget {
                     if (information.players[0].isHuman) {
                         players[0] = new LocalPlayer<>(information.players[0].name);
                     } else {
-                        players[0] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), "Random AI");
+                        players[0] = new ArtificialPlayer<>(new TicTacToeAIRSleep(information.players[0].computerDifficulty, information.players[1].computerThinkTime), information.players[0].name);
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer<>(information.players[1].name);
                     } else {
-                        players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardTicTacToe>(9), "MiniMax AI");
+                        players[1] = new ArtificialPlayer<>(new TicTacToeAIRSleep(information.players[1].computerDifficulty, information.players[1].computerThinkTime), information.players[1].name);
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
                         new ShowEnableTutorialWidget(
                                 () -> new TicTacToeTutorialWidget(() -> {
-                                    gameController = new TicTacToeBitController(players);
+                                    gameController = new TicTacToeController(players);
                                     gameController.start();
                                 }),
                                 () -> Platform.runLater(() -> {
-                                    gameController = new TicTacToeBitController(players);
+                                    gameController = new TicTacToeController(players);
                                     gameController.start();
                                 }),
                                 () -> AppSettings.getSettings().setFirstTTT(false)
                         );
                     } else {
-                        gameController = new TicTacToeBitController(players);
+                        gameController = new TicTacToeController(players);
                         gameController.start();
                     }
                     break;
@@ -82,27 +81,27 @@ public class LocalMultiplayerView extends ViewWidget {
                     if (information.players[0].isHuman) {
                         players[0] = new LocalPlayer<>(information.players[0].name);
                     } else {
-                        players[0] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), "Random AI");
+                        players[0] = new ArtificialPlayer<>(new ReversiAIR(), information.players[0].name);
                     }
                     if (information.players[1].isHuman) {
                         players[1] = new LocalPlayer<>(information.players[1].name);
                     } else {
-                        players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardReversi>(6), "MiniMax");
+                        players[1] = new ArtificialPlayer<>(new ReversiAIR(), information.players[1].name);
                     }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(
                                 () -> new ReversiTutorialWidget(() -> {
-                                    gameController = new ReversiBitController(players);
+                                    gameController = new ReversiController(players);
                                     gameController.start();
                                 }),
                                 () -> Platform.runLater(() -> {
-                                    gameController = new ReversiBitController(players);
+                                    gameController = new ReversiController(players);
                                     gameController.start();
                                 }),
                                 () -> AppSettings.getSettings().setFirstReversi(false)
                         );
                     } else {
-                        gameController = new ReversiBitController(players);
+                        gameController = new ReversiController(players);
                         gameController.start();
                     }
                     break;

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

@@ -1,5 +1,6 @@
 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;

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

@@ -3,6 +3,7 @@ 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;

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))
-					.postEvent();
+					.asyncPostEvent();
 			}
 		);
 
@@ -86,7 +86,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setFxVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.FX))
-					.postEvent();
+					.asyncPostEvent();
 			}
 		);
 
@@ -98,7 +98,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setMusicVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.MUSIC))
-					.postEvent();
+					.asyncPostEvent();
 			}
 		);
 

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,13 +16,11 @@ 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 BaseTutorialWidget tutorialWidget;
+    private static final Logger logger = LogManager.getLogger(AppContext.class);
 
     public static LocalizationAsset getLocalization() {
         return localization;
@@ -75,12 +73,4 @@ 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))
-				.postEvent();
+				.asyncPostEvent();
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.fxVolume, VolumeControl.FX))
-				.postEvent();
+				.asyncPostEvent();
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.musicVolume, VolumeControl.MUSIC))
-				.postEvent();
+				.asyncPostEvent();
 	}
 
 	public static SettingsAsset getPath() {

framework/pom.xml

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

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

@@ -5,29 +5,26 @@ 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.bus.EventBus;
+import org.toop.framework.eventbus.GlobalEventBus;
 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(eventBus)
+        new EventFlow()
                 .listen(AudioEvents.StopAudioManager.class, this::handleStopMusicManager, false)
                 .listen(AudioEvents.PlayEffect.class, this::handlePlaySound, false)
                 .listen(AudioEvents.SkipMusic.class, this::handleSkipSong, false)
@@ -76,7 +73,7 @@ public class AudioEventListener<T extends AudioResource, K extends AudioResource
     }
 
     private void handleGetVolume(AudioEvents.GetVolume event) {
-        eventBus.post(new AudioEvents.GetVolumeResponse(
+        GlobalEventBus.postAsync(new AudioEvents.GetVolumeResponse(
                 audioVolumeManager.getVolume(event.controlType()),
                 event.identifier()));
     }

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

@@ -6,7 +6,8 @@ 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.bus.EventBus;
+import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.resource.types.AudioResource;
 
 import java.util.*;
@@ -17,7 +18,6 @@ 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,8 +27,7 @@ public class MusicManager<T extends AudioResource> implements org.toop.framework
     private ScheduledExecutorService scheduler;
 
 
-    public MusicManager(EventBus eventbus, List<T> resources, boolean shuffleMusic) {
-        this.eventBus = eventbus;
+    public MusicManager(List<T> resources, boolean shuffleMusic) {
         this.dispatcher = new JavaFXDispatcher();
         this.resources = resources;
         // Shuffle if wanting to shuffle
@@ -41,8 +40,7 @@ public class MusicManager<T extends AudioResource> implements org.toop.framework
      * {@code @TestsOnly} DO NOT USE
      */
     @TestsOnly
-    public MusicManager(EventBus eventBus, List<T> resources, Dispatcher dispatcher) {
-        this.eventBus = eventBus;
+    public MusicManager(List<T> resources, Dispatcher dispatcher) {
         this.dispatcher = dispatcher;
         this.resources = new ArrayList<>(resources);
         backgroundMusic.addAll(resources);
@@ -126,7 +124,7 @@ public class MusicManager<T extends AudioResource> implements org.toop.framework
         Runnable currentMusicTask = new Runnable() {
             @Override
             public void run() {
-                eventBus.post(new AudioEvents.PlayingMusic(track.getName(), track.currentPosition(), track.duration()));
+                GlobalEventBus.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,10 +2,18 @@ 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,6 +2,8 @@ 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,7 +1,12 @@
 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,14 +13,10 @@ 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 EventBus}.
+ * type-safe and chainable manner. It is designed to work with the {@link GlobalEventBus}.
  *
  * <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
@@ -35,8 +31,6 @@ 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;
 
@@ -44,19 +38,13 @@ public class EventFlow {
     private EventType event = null;
 
     /** The listener returned by GlobalEventBus subscription. Used for unsubscription. */
-    private final List<NamedSubscriber<?>> listeners = new ArrayList<>();
+    private final List<ListenerHandler<?>> 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(EventBus eventBus) {
-        this.eventBus = eventBus;
-    }
-
-    public EventFlow() {
-        this.eventBus = GlobalEventBus.get();
-    }
+    public EventFlow() {}
 
     /**
      *
@@ -157,19 +145,21 @@ public class EventFlow {
 
             action.accept(eventClass);
 
-            if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
+            if (unsubscribeAfterSuccess) unsubscribe(id);
 
             this.result = eventClass.result();
         };
 
-        var subscriber = new DefaultNamedSubscriber<>(
+        // TODO Remove casts
+        var listener = new ListenerHandler<>(
+                id,
                 name,
-                event,
-                newAction
+                (Class<ResponseToUniqueEvent>) event,
+                (Consumer<ResponseToUniqueEvent>) newAction
         );
 
-        eventBus.subscribe(subscriber);
-        this.listeners.add(subscriber);
+        GlobalEventBus.subscribe(listener);
+        this.listeners.add(listener);
         return this;
     }
 
@@ -237,7 +227,7 @@ public class EventFlow {
                     TT typedEvent = (TT) uuidEvent;
                     action.accept(typedEvent);
 
-                    if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
+                    if (unsubscribeAfterSuccess) unsubscribe(id);
 
                     this.result = typedEvent.result();
                 } catch (ClassCastException _) {
@@ -249,13 +239,14 @@ public class EventFlow {
             }
         };
 
-        var listener = new DefaultNamedSubscriber<>(
+        var listener = new ListenerHandler<>(
+                id,
                 name,
                 (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0],
                 newAction
         );
 
-        eventBus.subscribe(listener);
+        GlobalEventBus.subscribe(listener);
         this.listeners.add(listener);
         return this;
     }
@@ -293,16 +284,17 @@ public class EventFlow {
         Consumer<TT> newAction = eventc -> {
             action.accept(eventc);
 
-            if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
+            if (unsubscribeAfterSuccess) unsubscribe(id);
         };
 
-        var listener = new DefaultNamedSubscriber<>(
+        var listener = new ListenerHandler<>(
+                        id,
                         name,
                         event,
                         newAction
                 );
 
-        eventBus.subscribe(listener);
+        GlobalEventBus.subscribe(listener);
         this.listeners.add(listener);
         return this;
     }
@@ -370,7 +362,7 @@ public class EventFlow {
             try {
                 TT typedEvent = (TT) nonUuidEvent;
                 action.accept(typedEvent);
-                if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
+                if (unsubscribeAfterSuccess) unsubscribe(id);
             } catch (ClassCastException _) {
                 throw new ClassCastException(
                         "Cannot cast "
@@ -379,13 +371,14 @@ public class EventFlow {
             }
         };
 
-        var listener = new DefaultNamedSubscriber<>(
+        var listener = new ListenerHandler<>(
+                id,
                 name,
                 eventClass,
                 newAction
         );
 
-        eventBus.subscribe(listener);
+        GlobalEventBus.subscribe(listener);
         this.listeners.add(listener);
         return this;
     }
@@ -408,18 +401,15 @@ public class EventFlow {
      * Posts the event added through {@link #addPostEvent}.
      */
     public EventFlow postEvent() {
-        eventBus.post(this.event);
+        GlobalEventBus.post(this.event);
         return this;
     }
 
     /**
      * Posts the event added through {@link #addPostEvent} asynchronously.
-     *
-     * @deprecated use {@link #postEvent()} instead.
      */
-    @Deprecated
     public EventFlow asyncPostEvent() {
-        eventBus.post(this.event);
+        GlobalEventBus.postAsync(this.event);
         return this;
     }
 
@@ -427,12 +417,28 @@ public class EventFlow {
      *
      * Unsubscribe from an event.
      *
-     * @param action The listener object to remove and unsubscribe.
+     * @param listenerObject The listener object to remove and unsubscribe.
      */
-    public void unsubscribe(Consumer<?> action) {
+    public void unsubscribe(Object listenerObject) {
         this.listeners.removeIf(handler -> {
-            if (handler.handler().equals(action)) {
-                eventBus.unsubscribe(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);
                 return true;
             }
             return false;
@@ -446,8 +452,8 @@ public class EventFlow {
      */
     public void unsubscribe(String name) {
         this.listeners.removeIf(handler -> {
-            if (handler.id().equals(name)) {
-                eventBus.unsubscribe(handler);
+            if (handler.getName().equals(name)) {
+                GlobalEventBus.unsubscribe(handler);
                 return true;
             }
             return false;
@@ -459,7 +465,7 @@ public class EventFlow {
      */
     public void unsubscribeAll() {
         listeners.removeIf(handler -> {
-            eventBus.unsubscribe(handler);
+            GlobalEventBus.unsubscribe(handler);
             return true;
         });
     }
@@ -497,8 +503,8 @@ public class EventFlow {
      *
      * @return Copy of the list of listeners.
      */
-    public Subscriber<?>[] getListeners() {
-        return listeners.toArray(new Subscriber[0]);
+    public ListenerHandler[] getListeners() {
+        return listeners.toArray(new ListenerHandler[0]);
     }
 
     /**

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

@@ -1,46 +1,193 @@
 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.toop.framework.eventbus.bus.DisruptorEventBus;
-import org.toop.framework.eventbus.bus.EventBus;
+import org.apache.logging.log4j.Logger;
 import org.toop.framework.eventbus.events.EventType;
-import org.toop.framework.eventbus.store.DefaultSubscriberStore;
-import org.toop.framework.eventbus.subscriber.Subscriber;
+import org.toop.framework.eventbus.events.UniqueEvent;
 
-public class GlobalEventBus implements EventBus {
-    private static final EventBus INSTANCE = new DisruptorEventBus(
-            LogManager.getLogger(DisruptorEventBus.class),
-            new DefaultSubscriberStore()
-    );
+/**
+ * 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);
 
+    /** Map of event class to type-specific listeners. */
+    private static final Map<Class<?>, CopyOnWriteArrayList<ListenerHandler<?>>>
+            LISTENERS = new ConcurrentHashMap<>();
+
+    /** 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() {}
 
-    public static EventBus get() {
-        return INSTANCE;
+    /** Wrapper used inside the ring buffer. */
+    private static class EventHolder {
+        EventType event;
     }
 
-    @Override
-    public void subscribe(Subscriber<? extends EventType> listener) {
-        INSTANCE.subscribe(listener);
+    // ------------------------------------------------------------------------
+    // 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 unsubscribe(Subscriber<? extends EventType> listener) {
-        INSTANCE.unsubscribe(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 <T extends EventType> void post(T event) {
-        INSTANCE.post(event);
+    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 void shutdown() {
-        INSTANCE.shutdown();
+    // 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 void reset() {
-        INSTANCE.reset();
+    // ------------------------------------------------------------------------
+    // Posting
+    // ------------------------------------------------------------------------
+    public static <T extends EventType> void post(T event) {
+        dispatchEvent(event); // synchronous
+    }
+
+    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);
+        }
+    }
+
+    @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

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

@@ -1,53 +0,0 @@
-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.function.Consumer;
-
-public class DefaultEventBus implements EventBus {
-    private final Logger logger;
-    private final SubscriberStore eventsHolder;
-
-    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((EventType) eventClass.cast(event));
-            }
-        }
-    }
-
-    @Override
-    public void shutdown() {
-        eventsHolder.reset();
-    }
-
-    @Override
-    public void reset() {
-        eventsHolder.reset();
-    }
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +0,0 @@
-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/gameFramework/LongPairConsumer.java

@@ -1,6 +0,0 @@
-package org.toop.framework.gameFramework;
-
-@FunctionalInterface
-public interface LongPairConsumer {
-    void accept(long a, long b);
-}

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

@@ -1,18 +0,0 @@
-package org.toop.framework.gameFramework.controller;
-
-import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
-import org.toop.framework.gameFramework.model.game.threadBehaviour.Controllable;
-import org.toop.framework.networking.events.NetworkEvents;
-
-public interface GameController extends Controllable, UpdatesGameUI {
-    /** Called when it is this player's turn to make a move. */
-    void onYourTurn(NetworkEvents.YourTurnResponse event);
-
-    /** Called when a move from another player is received. */
-    void onMoveReceived(NetworkEvents.GameMoveResponse event);
-
-    /** Called when the game has finished, with the final result. */
-    void gameFinished(NetworkEvents.GameResultResponse event);
-
-    void sendMove(long clientId, long move);
-}

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

@@ -0,0 +1,108 @@
+package org.toop.framework.gameFramework.model.game;
+
+import org.toop.framework.gameFramework.model.player.Player;
+
+import java.util.Arrays;
+
+public abstract class AbstractGame<T extends TurnBasedGame<T>> implements TurnBasedGame<T> {
+    private final int playerCount;  // How many players are playing
+    private final Player<T>[] players;
+    private int turn = 0;           // What turn it is in the game
+
+    /** Constant representing an empty position on the board. */
+    public static final int EMPTY = -1;
+
+    /** Number of rows in the game board. */
+    private final int rowSize;
+
+    /** Number of columns in the game board. */
+    private final int columnSize;
+
+    /** The game board stored as a one-dimensional array. */
+    private final int[] board;
+
+
+
+    protected AbstractGame(int rowSize, int columnSize, int playerCount, Player<T>[] players) {
+        assert rowSize > 0 && columnSize > 0;
+
+        this.rowSize = rowSize;
+        this.columnSize = columnSize;
+
+        this.players = players;
+
+        board = new int[rowSize * columnSize];
+        Arrays.fill(board, EMPTY);
+
+        this.playerCount = playerCount;
+    }
+
+    protected AbstractGame(AbstractGame<T> other){
+        this.rowSize = other.rowSize;
+        this.columnSize = other.columnSize;
+        this.board = other.board.clone();
+        this.playerCount = other.playerCount;
+        this.turn = other.turn;
+        // TODO: Make this a deep copy, add deep copy interface to Player
+        this.players = other.players;
+
+    }
+
+    public static boolean contains(int[] array, int value) {
+        // O(n)
+        for (int element : array){
+            if (element == value) return true;
+        }
+        return false;
+    }
+
+    public Player<T> getPlayer(int index) {
+        return players[index];
+    }
+
+    public int getPlayerCount(){return this.playerCount;}
+
+    protected void nextTurn() {
+        turn += 1;
+    }
+
+    public int getCurrentTurn() {
+        return turn % playerCount;
+    }
+
+    protected void setBoard(int position) {
+        setBoard(position, getCurrentTurn());
+    }
+
+    protected void setBoard(int position, int player) {
+        this.board[position] = player;
+    }
+
+    /**
+     * Returns the number of rows in the board.
+     *
+     * @return number of rows
+     */
+    public int getRowSize() {
+        return this.rowSize;
+    }
+
+    /**
+     * Returns the number of columns in the board.
+     *
+     * @return number of columns
+     */
+    public int getColumnSize() {
+        return this.columnSize;
+    }
+
+    /**
+     * Returns a copy of the current board state.
+     *
+     * @return a cloned array representing the board
+     */
+    public int[] getBoard() {
+        return this.board.clone();
+    }
+
+}

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

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

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

@@ -1,5 +1,5 @@
 package org.toop.framework.gameFramework.model.game;
 
-public interface DeepCopyable<T> {
+public interface DeepCopyable<T extends TurnBasedGame<T>> {
     T deepCopy();
 }

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

@@ -12,7 +12,7 @@ public interface Playable {
      *
      * @return an array of integers representing legal moves
      */
-    long getLegalMoves();
+    int[] getLegalMoves();
 
     /**
      * Plays the given move and returns the resulting game state.
@@ -20,5 +20,5 @@ public interface Playable {
      * @param move the move to apply
      * @return the {@link GameState} and additional info after the move
      */
-    PlayResult play(long move);
+    PlayResult play(int move);
 }

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

@@ -10,11 +10,11 @@ import org.toop.framework.networking.events.NetworkEvents;
 public interface SupportsOnlinePlay {
 
     /** Called when it is this player's turn to make a move. */
-    void onYourTurn(long clientId);
+    void onYourTurn(NetworkEvents.YourTurnResponse event);
 
     /** Called when a move from another player is received. */
-    void onMoveReceived(long move);
+    void onMoveReceived(NetworkEvents.GameMoveResponse event);
 
     /** Called when the game has finished, with the final result. */
-    void gameFinished(String condition);
+    void gameFinished(NetworkEvents.GameResultResponse event);
 }

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

@@ -1,7 +1,5 @@
 package org.toop.framework.gameFramework.model.game;
 
-public interface TurnBasedGame<T extends TurnBasedGame<T>> extends Playable, DeepCopyable<T>, PlayerProvider<T>, BoardProvider {
+public interface TurnBasedGame<T extends TurnBasedGame<T>> extends Playable, DeepCopyable<T>, PlayerProvider<T> {
     int getCurrentTurn();
-    int getPlayerCount();
-    int getWinner();
 }

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

@@ -2,12 +2,10 @@ package org.toop.framework.gameFramework.model.game.threadBehaviour;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.toop.framework.gameFramework.LongPairConsumer;
-import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.Player;
 
 import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
 
 /**
  * Base class for thread-based game behaviours.
@@ -16,9 +14,8 @@ import java.util.function.Consumer;
  * a running flag, a game reference, and a logger.
  * Subclasses implement the actual game-loop logic.
  */
-public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implements ThreadBehaviour {
-    private LongPairConsumer onSendMove;
-    private Runnable onUpdateUI;
+public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implements ThreadBehaviour<T> {
+
     /** Indicates whether the game loop or event processing is active. */
     protected final AtomicBoolean isRunning = new AtomicBoolean();
 
@@ -36,26 +33,4 @@ public abstract class AbstractThreadBehaviour<T extends TurnBasedGame<T>> implem
     public AbstractThreadBehaviour(T game) {
         this.game = game;
     }
-
-    protected void updateUI(){
-        if (onUpdateUI != null) {
-            onUpdateUI.run();
-        }
-    }
-
-    protected void sendMove(long clientId, long move){
-        if (onSendMove != null) {
-            onSendMove.accept(clientId, move);
-        }
-    }
-
-    @Override
-    public void setOnUpdateUI(Runnable onUpdateUI) {
-        this.onUpdateUI = onUpdateUI;
-    }
-
-    @Override
-    public void setOnSendMove(LongPairConsumer onSendMove) {
-        this.onSendMove = onSendMove;
-    }
 }

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

@@ -1,18 +1,13 @@
 package org.toop.framework.gameFramework.model.game.threadBehaviour;
 
-import org.toop.framework.gameFramework.LongPairConsumer;
-import org.toop.framework.gameFramework.controller.GameController;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-
-import java.util.function.Consumer;
+import org.toop.framework.gameFramework.model.player.AbstractPlayer;
+import org.toop.framework.gameFramework.model.player.Player;
 
 /**
  * Strategy interface for controlling game thread behavior.
  * <p>
  * Defines how a game's execution is started, stopped, and which player is active.
  */
-public interface ThreadBehaviour extends Controllable {
-    void setOnUpdateUI(Runnable onUpdateUI);
-    void setOnSendMove(LongPairConsumer onSendMove);
+public interface ThreadBehaviour<T extends TurnBasedGame<T>> extends Controllable {
 }
-

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

@@ -1,7 +0,0 @@
-package org.toop.framework.gameFramework.model.player;
-
-import org.toop.framework.gameFramework.model.game.DeepCopyable;
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-
-public interface AI<T extends TurnBasedGame<T>> extends MoveProvider<T>, DeepCopyable<AI<T>> {
-}

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

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

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

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

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

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

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

@@ -1,7 +1,6 @@
 package org.toop.framework.gameFramework.model.player;
 
-import org.toop.framework.gameFramework.model.game.DeepCopyable;
 import org.toop.framework.gameFramework.model.game.TurnBasedGame;
 
-public interface Player<T extends TurnBasedGame<T>> extends NameProvider, MoveProvider<T>, DeepCopyable<Player<T>> {
+public interface Player<T extends TurnBasedGame<T>> extends NameProvider, MoveProvider<T> {
 }

framework/src/main/java/org/toop/framework/gameFramework/view/GUIEvents.java

@@ -10,6 +10,10 @@ import org.toop.framework.eventbus.events.GenericEvent;
  * player actions, and game completion.
  */
 public class GUIEvents extends EventsBase {
+
+    /** Event to refresh or redraw the game canvas. */
+    public record RefreshGameCanvas() implements GenericEvent {}
+
     /**
      * Event indicating the game has ended.
      *
@@ -19,8 +23,8 @@ public class GUIEvents extends EventsBase {
     public record GameEnded(boolean winOrTie, int winner) implements GenericEvent {}
 
     /** Event indicating a player has attempted a move. */
-    public record PlayerAttemptedMove(long move) implements GenericEvent {}
+    public record PlayerAttemptedMove(int move) implements GenericEvent {}
 
     /** Event indicating a player is hovering over a move (for UI feedback). */
-    public record PlayerMoveHovered(long move) implements GenericEvent {}
+    public record PlayerMoveHovered(int move) implements GenericEvent {}
 }

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

@@ -4,20 +4,19 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.framework.SnowflakeGenerator;
 import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.eventbus.bus.EventBus;
 import org.toop.framework.networking.events.NetworkEvents;
 import org.toop.framework.networking.exceptions.ClientNotFoundException;
 import org.toop.framework.networking.interfaces.NetworkingClientManager;
 
 public class NetworkingClientEventListener {
-    private static final Logger logger = LogManager.getLogger(NetworkingClientEventListener.class);
 
+    private static final Logger logger = LogManager.getLogger(NetworkingClientEventListener.class);
     private final NetworkingClientManager clientManager;
 
     /** Starts a connection manager, to manage, connections. */
-    public NetworkingClientEventListener(EventBus eventBus, NetworkingClientManager clientManager) {
+    public NetworkingClientEventListener(NetworkingClientManager clientManager) {
         this.clientManager = clientManager;
-        new EventFlow(eventBus)
+        new EventFlow()
                 .listen(NetworkEvents.StartClient.class, this::handleStartClient, false)
                 .listen(NetworkEvents.SendCommand.class, this::handleCommand, false)
                 .listen(NetworkEvents.SendLogin.class, this::handleSendLogin, false)
@@ -41,7 +40,6 @@ public class NetworkingClientEventListener {
 
     void handleStartClient(NetworkEvents.StartClient event) {
         long clientId = SnowflakeGenerator.nextId();
-        new EventFlow().addPostEvent(new NetworkEvents.CreatedIdForClient(clientId, event.identifier())).postEvent();
         clientManager.startClient(
                 clientId,
                 event.networkingClient(),

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

@@ -8,8 +8,7 @@ import java.util.concurrent.TimeUnit;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.eventbus.bus.EventBus;
+import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.networking.events.NetworkEvents;
 import org.toop.framework.networking.exceptions.ClientNotFoundException;
 import org.toop.framework.networking.exceptions.CouldNotConnectException;
@@ -18,13 +17,9 @@ import org.toop.framework.networking.types.NetworkingConnector;
 
 public class NetworkingClientManager implements org.toop.framework.networking.interfaces.NetworkingClientManager {
     private static final Logger logger = LogManager.getLogger(NetworkingClientManager.class);
-
-    private final EventBus eventBus;
     private final Map<Long, NetworkingClient> networkClients = new ConcurrentHashMap<>();
 
-    public NetworkingClientManager(EventBus eventBus) {
-        this.eventBus = eventBus;
-    }
+    public NetworkingClientManager() {}
 
     private void connectHelper(
             long id,
@@ -33,16 +28,8 @@ public class NetworkingClientManager implements org.toop.framework.networking.in
             Runnable onSuccess,
             Runnable onFailure
     ) {
-
         ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
 
-        EventFlow closeEvent = new EventFlow()
-                .listen(
-                    NetworkEvents.CloseClient.class,
-                    e -> {
-                            if (e.clientId() == id) scheduler.shutdownNow();
-                        }, "close");
-
         Runnable connectTask = new Runnable() {
             int attempts = 0;
 
@@ -59,7 +46,7 @@ public class NetworkingClientManager implements org.toop.framework.networking.in
                     nClient.connect(id, nConnector.host(), nConnector.port());
                     networkClients.put(id, nClient);
                     logger.info("New client started successfully for {}:{}", nConnector.host(), nConnector.port());
-                    eventBus.post(new NetworkEvents.ConnectTry(id, attempts, nConnector.reconnectAttempts(), true));
+                    GlobalEventBus.post(new NetworkEvents.ConnectTry(id, attempts, nConnector.reconnectAttempts(), true));
                     onSuccess.run();
                     scheduler.shutdown();
                 } catch (CouldNotConnectException e) {
@@ -67,17 +54,17 @@ public class NetworkingClientManager implements org.toop.framework.networking.in
                     if (attempts < nConnector.reconnectAttempts()) {
                         logger.warn("Could not connect to {}:{}. Retrying in {} {}",
                                 nConnector.host(), nConnector.port(), nConnector.timeout(), nConnector.timeUnit());
-                        eventBus.post(new NetworkEvents.ConnectTry(id, attempts, nConnector.reconnectAttempts(), false));
+                        GlobalEventBus.post(new NetworkEvents.ConnectTry(id, attempts, nConnector.reconnectAttempts(), false));
                         scheduler.schedule(this, nConnector.timeout(), nConnector.timeUnit());
                     } else {
                         logger.error("Failed to start client for {}:{} after {} attempts", nConnector.host(), nConnector.port(), attempts);
-                        eventBus.post(new NetworkEvents.ConnectTry(id, -1, nConnector.reconnectAttempts(), false));
+                        GlobalEventBus.post(new NetworkEvents.ConnectTry(id, -1, nConnector.reconnectAttempts(), false));
                         onFailure.run();
                         scheduler.shutdown();
                     }
                 } catch (Exception e) {
                     logger.error("Unexpected exception during startClient", e);
-                    eventBus.post(new NetworkEvents.ConnectTry(id, -1, nConnector.reconnectAttempts(), false));
+                    GlobalEventBus.post(new NetworkEvents.ConnectTry(id, -1, nConnector.reconnectAttempts(), false));
                     onFailure.run();
                     scheduler.shutdown();
                 }
@@ -85,8 +72,6 @@ public class NetworkingClientManager implements org.toop.framework.networking.in
         };
 
         scheduler.schedule(connectTask, 0, TimeUnit.MILLISECONDS);
-//
-//        closeEvent.unsubscribe("close");
     }
 
     @Override

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

@@ -11,7 +11,6 @@ import io.netty.handler.codec.string.StringEncoder;
 import io.netty.util.CharsetUtil;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.toop.framework.eventbus.bus.EventBus;
 import org.toop.framework.networking.exceptions.CouldNotConnectException;
 import org.toop.framework.networking.handlers.NetworkingGameClientHandler;
 import org.toop.framework.networking.interfaces.NetworkingClient;
@@ -20,13 +19,9 @@ import java.net.InetSocketAddress;
 
 public class TournamentNetworkingClient implements NetworkingClient {
     private static final Logger logger = LogManager.getLogger(TournamentNetworkingClient.class);
-
-    private final EventBus eventBus;
     private Channel channel;
 
-    public TournamentNetworkingClient(EventBus eventBus) {
-        this.eventBus = eventBus;
-    }
+    public TournamentNetworkingClient() {}
 
     @Override
     public InetSocketAddress getAddress() {
@@ -45,7 +40,7 @@ public class TournamentNetworkingClient implements NetworkingClient {
                     new ChannelInitializer<SocketChannel>() {
                         @Override
                         public void initChannel(SocketChannel ch) {
-                            NetworkingGameClientHandler handler = new NetworkingGameClientHandler(eventBus, clientId);
+                            NetworkingGameClientHandler handler = new NetworkingGameClientHandler(clientId);
 
                             ChannelPipeline pipeline = ch.pipeline();
                             pipeline.addLast(new LineBasedFrameDecoder(1024)); // split at \n

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

@@ -4,7 +4,6 @@ import java.util.*;
 import java.util.concurrent.CompletableFuture;
 
 import org.toop.annotations.AutoResponseResult;
-import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.eventbus.events.*;
 import org.toop.framework.networking.interfaces.NetworkingClient;
 import org.toop.framework.networking.types.NetworkingConnector;
@@ -12,7 +11,7 @@ import org.toop.framework.networking.types.NetworkingConnector;
 /**
  * Defines all event types related to the networking subsystem.
  * <p>
- * These events are used in conjunction with the {@link GlobalEventBus}
+ * These events are used in conjunction with the {@link org.toop.framework.eventbus.GlobalEventBus}
  * and {@link org.toop.framework.eventbus.EventFlow} to communicate between components
  * such as networking clients, managers, and listeners.
  * </p>
@@ -167,10 +166,6 @@ public class NetworkEvents extends EventsBase {
             long identifier)
             implements UniqueEvent {}
 
-    public record CreatedIdForClient(long clientId, long identifier) implements ResponseToUniqueEvent {}
-
-    public record ConnectTry(long clientId, int amount, int maxAmount, boolean success) implements GenericEvent {}
-
     /**
      * Response confirming that a client has been successfully started.
      * <p>
@@ -186,6 +181,8 @@ public class NetworkEvents extends EventsBase {
     public record StartClientResponse(long clientId, boolean successful, long identifier)
             implements ResponseToUniqueEvent {}
 
+    public record ConnectTry(long clientId, int amount, int maxAmount, boolean success) implements GenericEvent {}
+
     /**
      * Requests reconnection of an existing client using its previous configuration.
      * <p>

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

@@ -8,17 +8,15 @@ import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.toop.framework.eventbus.bus.EventBus;
+import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.networking.events.NetworkEvents;
 
 public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
     private static final Logger logger = LogManager.getLogger(NetworkingGameClientHandler.class);
 
-    private final EventBus eventBus;
     private final long connectionId;
 
-    public NetworkingGameClientHandler(EventBus eventBus, long connectionId) {
-        this.eventBus = eventBus;
+    public NetworkingGameClientHandler(long connectionId) {
         this.connectionId = connectionId;
     }
 
@@ -42,7 +40,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                     "Received SVR message from server-{}, data: {}",
                     ctx.channel().remoteAddress(),
                     msg);
-            eventBus.post(new NetworkEvents.ServerResponse(this.connectionId));
+            new EventFlow()
+                    .addPostEvent(new NetworkEvents.ServerResponse(this.connectionId))
+                    .asyncPostEvent();
             parseServerReturn(rec);
             return;
         }
@@ -113,7 +113,11 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                         .map(m -> m.group(1).trim())
                         .toArray(String[]::new);
 
-        eventBus.post(new NetworkEvents.GameMoveResponse(this.connectionId, msg[0], msg[1], msg[2]));
+        new EventFlow()
+                .addPostEvent(
+                        new NetworkEvents.GameMoveResponse(
+                                this.connectionId, msg[0], msg[1], msg[2]))
+                .asyncPostEvent();
     }
 
     private void gameWinConditionHandler(String rec) {
@@ -124,7 +128,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                 .findFirst()
                 .orElse("");
 
-        eventBus.post(new NetworkEvents.GameResultResponse(this.connectionId, condition));
+        new EventFlow()
+                .addPostEvent(new NetworkEvents.GameResultResponse(this.connectionId, condition))
+                .asyncPostEvent();
     }
 
     private void gameChallengeHandler(String rec) {
@@ -139,9 +145,17 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                             .toArray(String[]::new);
 
             if (isCancelled)
-                eventBus.post(new NetworkEvents.GameResultResponse(this.connectionId, msg[0]));
+                new EventFlow()
+                        .addPostEvent(
+                                new NetworkEvents.ChallengeCancelledResponse(
+                                        this.connectionId, msg[0]))
+                        .asyncPostEvent();
             else
-                eventBus.post(new NetworkEvents.ChallengeResponse(this.connectionId, msg[0], msg[1], msg[2]));
+                new EventFlow()
+                        .addPostEvent(
+                                new NetworkEvents.ChallengeResponse(
+                                        this.connectionId, msg[0], msg[1], msg[2]))
+                        .asyncPostEvent();
         } catch (ArrayIndexOutOfBoundsException e) {
             logger.error("Array out of bounds for: {}", rec, e);
         }
@@ -157,7 +171,11 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                             .toArray(String[]::new);
 
             // [0] playerToMove, [1] gameType, [2] opponent
-            eventBus.post(new NetworkEvents.GameMatchResponse(this.connectionId, msg[0], msg[1], msg[2]));
+            new EventFlow()
+                    .addPostEvent(
+                            new NetworkEvents.GameMatchResponse(
+                                    this.connectionId, msg[0], msg[1], msg[2]))
+                    .asyncPostEvent();
         } catch (ArrayIndexOutOfBoundsException e) {
             logger.error("Array out of bounds for: {}", rec, e);
         }
@@ -172,7 +190,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                         .toString()
                         .trim();
 
-        eventBus.post(new NetworkEvents.YourTurnResponse(this.connectionId, msg));
+        new EventFlow()
+                .addPostEvent(new NetworkEvents.YourTurnResponse(this.connectionId, msg))
+                .asyncPostEvent();
     }
 
     private void playerlistHandler(String rec) {
@@ -183,7 +203,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                         .map(m -> m.group(1).trim())
                         .toArray(String[]::new);
 
-        eventBus.post(new NetworkEvents.PlayerlistResponse(this.connectionId, players));
+        new EventFlow()
+                .addPostEvent(new NetworkEvents.PlayerlistResponse(this.connectionId, players))
+                .asyncPostEvent();
     }
 
     private void gamelistHandler(String rec) {
@@ -194,7 +216,9 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                         .map(m -> m.group(1).trim())
                         .toArray(String[]::new);
 
-        eventBus.post(new NetworkEvents.GamelistResponse(this.connectionId, gameTypes));
+        new EventFlow()
+                .addPostEvent(new NetworkEvents.GamelistResponse(this.connectionId, gameTypes))
+                .asyncPostEvent();
     }
 
     private void helpHandler(String rec) {

framework/src/main/java/org/toop/framework/resource/ResourceManager.java

@@ -92,6 +92,11 @@ public class ResourceManager {
         return asset.getResource();
     }
 
+    //    @SuppressWarnings("unchecked")
+    //    public static <T extends BaseResource> ArrayList<ResourceMeta<T>> getAllOfType() {
+    //        return (ArrayList<ResourceMeta<T>>) (ArrayList<?>) new ArrayList<>(assets.values());
+    //    }
+
     /**
      * Retrieve all assets of a specific resource type.
      *

framework/src/main/java/org/toop/framework/resource/resources/LocalizationAsset.java

@@ -147,6 +147,24 @@ public class LocalizationAsset extends BaseResource implements LoadableResource,
         return this.baseName;
     }
 
+    //    /**
+    //     * Extracts the base name from a file name.
+    //     *
+    //     * @param fileName the file name
+    //     * @return base name without locale or extension
+    //     */
+    //    private String getBaseName(String fileName) {
+    //        int dotIndex = fileName.lastIndexOf('.');
+    //        String nameWithoutExtension = (dotIndex > 0) ? fileName.substring(0, dotIndex) :
+    // fileName;
+    //
+    //        int underscoreIndex = nameWithoutExtension.indexOf('_');
+    //        if (underscoreIndex > 0) {
+    //            return nameWithoutExtension.substring(0, underscoreIndex);
+    //        }
+    //        return nameWithoutExtension;
+    //    }
+
     /**
      * Extracts a locale from a file name based on the pattern "base_LOCALE.properties".
      *

framework/src/main/java/org/toop/framework/resource/types/BundledResource.java

@@ -69,4 +69,9 @@ public interface BundledResource {
      * @return the base name used to identify this bundled resource
      */
     String getBaseName();
+
+    //    /**
+    //    Returns the name
+    //    */
+    //    String getDefaultName();
 }

framework/src/test/java/org/toop/framework/audio/MusicManagerTest.java

@@ -3,7 +3,6 @@ package org.toop.framework.audio;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.toop.framework.dispatch.interfaces.Dispatcher;
-import org.toop.framework.eventbus.GlobalEventBus;
 import org.toop.framework.resource.resources.BaseResource;
 import org.toop.framework.resource.types.AudioResource;
 
@@ -95,7 +94,7 @@ public class MusicManagerTest {
 
         List<MockAudioResource> resources = List.of(track1, track2, track3);
 
-        manager = new MusicManager<>(GlobalEventBus.get(), resources, dispatcher);
+        manager = new MusicManager<>(resources, dispatcher);
     }
 
     @Test
@@ -189,7 +188,7 @@ public class MusicManagerTest {
             manyTracks.add(new MockAudioResource("track" + i));
         }
 
-        MusicManager<MockAudioResource> multiManager = new MusicManager<>(GlobalEventBus.get(), manyTracks, dispatcher);
+        MusicManager<MockAudioResource> multiManager = new MusicManager<>(manyTracks, dispatcher);
 
         for (int i = 0; i < manyTracks.size() - 1; i++) {
             multiManager.play();

framework/src/test/java/org/toop/framework/eventbus/EventFlowStressTest.java

@@ -79,7 +79,7 @@
             executor.submit(() -> {
                 for (int i = 0; i < EVENTS_PER_THREAD; i++) {
                     var _ = new EventFlow().addPostEvent(HeavyEvent.class, "payload-" + i)
-                            .postEvent();
+                            .asyncPostEvent();
                 }
             });
         }

game/pom.xml

@@ -105,16 +105,6 @@
             <version>0.1</version>
             <scope>compile</scope>
         </dependency>
-        <dependency>
-            <groupId>org.deeplearning4j</groupId>
-            <artifactId>deeplearning4j-core</artifactId>
-            <version>1.0.0-M2.1</version>
-        </dependency>
-        <dependency>
-            <groupId>org.nd4j</groupId>
-            <artifactId>nd4j-native-platform</artifactId>
-            <version>1.0.0-M2.1</version>
-        </dependency>
 
     </dependencies>
 

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

@@ -1,86 +0,0 @@
-package org.toop.game;
-
-import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import org.toop.framework.gameFramework.model.player.Player;
-
-import java.util.Arrays;
-import java.util.concurrent.atomic.AtomicInteger;
-
-// There is AI performance to be gained by getting rid of non-primitives and thus speeding up deepCopy
-public abstract class BitboardGame<T extends BitboardGame<T>> implements TurnBasedGame<T> {
-	private final int columnSize;
-	private final int rowSize;
-
-    private Player<T>[] players;
-
-	// long is 64 bits. Every game has a limit of 64 cells maximum.
-	private final long[] playerBitboard;
-	private int currentTurn = 0;
-
-	public BitboardGame(int columnSize, int rowSize, int playerCount, Player<T>[] players) {
-		this.columnSize = columnSize;
-		this.rowSize = rowSize;
-        this.players = players;
-		this.playerBitboard = new long[playerCount];
-
-		Arrays.fill(playerBitboard, 0L);
-	}
-
-	public BitboardGame(BitboardGame<T> other) {
-		this.columnSize = other.columnSize;
-		this.rowSize = other.rowSize;
-
-		this.playerBitboard = other.playerBitboard.clone();
-		this.currentTurn = other.currentTurn;
-        this.players = Arrays.stream(other.players)
-                .map(Player<T>::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<T> getPlayer(int index) {return players[index];}
-
-	public int getCurrentPlayerIndex() {
-        return currentTurn % playerBitboard.length;
-	}
-
-	public int getNextPlayer() {
-		return (currentTurn + 1) % playerBitboard.length;
-	}
-
-    public Player<T> getCurrentPlayer(){
-        return players[getCurrentPlayerIndex()];
-    }
-
-
-
-    @Override
-    public long[] getBoard() {return this.playerBitboard;}
-
-	public void nextTurn() {
-        currentTurn++;
-	}
-}

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

@@ -8,8 +8,6 @@ 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>
@@ -18,14 +16,18 @@ import java.util.function.Consumer;
  */
 public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> 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) {
+    public LocalFixedRateThreadBehaviour(T game, Player<T>[] players) {
         super(game);
+        this.players = players;
     }
 
     /** Starts the game loop thread if not already running. */
@@ -50,7 +52,7 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
      */
     @Override
     public void run() {
-        final int UPS = 1;
+        final int UPS = 60;
         final long UPDATE_INTERVAL = 1_000_000_000L / UPS;
         long nextUpdate = System.nanoTime();
 
@@ -60,10 +62,9 @@ public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends A
                 nextUpdate += UPDATE_INTERVAL;
 
                 Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
-                long move = currentPlayer.getMove(game.deepCopy());
+                int move = currentPlayer.getMove(game.deepCopy());
                 PlayResult result = game.play(move);
-
-                updateUI();
+                new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
 
                 GameState state = result.state();
                 switch (state) {

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

@@ -8,8 +8,6 @@ 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>
@@ -22,8 +20,9 @@ public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractTh
      * 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) {
+    public LocalThreadBehaviour(T game, Player<T>[] players) {
         super(game);
     }
 
@@ -49,10 +48,9 @@ public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractTh
     public void run() {
         while (isRunning.get()) {
             Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
-            long move = currentPlayer.getMove(game.deepCopy());
+            int move = currentPlayer.getMove(game.deepCopy());
             PlayResult result = game.play(move);
-
-            updateUI();
+            new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
 
             GameState state = result.state();
             switch (state) {

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

@@ -3,7 +3,9 @@ package org.toop.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.player.Player;
 import org.toop.game.players.OnlinePlayer;
@@ -15,12 +17,19 @@ import org.toop.game.players.OnlinePlayer;
  * for the local player while receiving moves from other players.
  */
 public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements SupportsOnlinePlay {
+
+    /** The local player controlled by this client. */
+    private final Player<T> mainPlayer;
+    private final int playerTurn;
+
     /**
      * Creates behaviour and sets the first local player
      * (non-online player) from the given array.
      */
-    public OnlineThreadBehaviour(T game) {
+    public OnlineThreadBehaviour(T game, Player<T>[] players) {
         super(game);
+        this.playerTurn = getFirstNotOnlinePlayer(players);
+        this.mainPlayer = players[this.playerTurn];
     }
 
     /** Finds the first non-online player in the array. */
@@ -50,31 +59,33 @@ public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractT
      * Sends the generated move back to the server.
      */
     @Override
-    public void onYourTurn(long clientId) {
+    public void onYourTurn(NetworkEvents.YourTurnResponse event) {
         if (!isRunning.get()) return;
-        long move = game.getPlayer(game.getCurrentTurn()).getMove(game.deepCopy());
-        sendMove(clientId, move);
+        int move = mainPlayer.getMove(game.deepCopy());
+        new EventFlow().addPostEvent(NetworkEvents.SendMove.class, event.clientId(), (short) move).postEvent();
     }
 
     /**
      * Handles a move received from the server for any player.
      * Updates the game state and triggers a UI refresh.
      */
-    public void onMoveReceived(long move) {
+    @Override
+    public void onMoveReceived(NetworkEvents.GameMoveResponse event) {
         if (!isRunning.get()) return;
-        game.play(move);
-
-        updateUI();
+        game.play(Integer.parseInt(event.move()));
+        new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
     }
 
     /**
      * 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.
      */
-    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();
+    @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();
             default -> {
                 logger.error("Invalid condition");
                 throw new RuntimeException("Unknown condition");

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

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

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

@@ -1,179 +0,0 @@
-package org.toop.game.games.reversi;
-
-import org.toop.framework.gameFramework.GameState;
-import org.toop.framework.gameFramework.model.game.PlayResult;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.BitboardGame;
-
-public class BitboardReversi extends BitboardGame<BitboardReversi> {
-
-    public record Score(int black, int white) {}
-
-	private final long notAFile = 0xfefefefefefefefeL;
-	private final long notHFile = 0x7f7f7f7f7f7f7f7fL;
-
-	public BitboardReversi(Player<BitboardReversi>[] players) {
-		super(8, 8, 2, players);
-
-		// 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() {
-		final long player = getPlayerBitboard(getCurrentPlayerIndex());
-		final long opponent = getPlayerBitboard(getNextPlayer());
-
-		long legalMoves = 0L;
-
-		// north & south
-		legalMoves |= computeMoves(player, opponent, 8, -1L);
-		legalMoves |= computeMoves(player, opponent, -8, -1L);
-
-		// east & west
-		legalMoves |= computeMoves(player, opponent, 1, notAFile);
-		legalMoves |= computeMoves(player, opponent, -1, notHFile);
-
-		// north-east & north-west & south-east & south-west
-		legalMoves |= computeMoves(player, opponent, 9, notAFile);
-		legalMoves |= computeMoves(player, opponent, 7, notHFile);
-		legalMoves |= computeMoves(player, opponent, -7, notAFile);
-		legalMoves |= computeMoves(player, opponent, -9, notHFile);
-
-		return legalMoves;
-	}
-
-	public long getFlips(long move) {
-		final long player = getPlayerBitboard(getCurrentPlayerIndex());
-		final long opponent = getPlayerBitboard(getNextPlayer());
-
-		long flips = 0L;
-
-		// north & south
-		flips |= computeFlips(move, player, opponent, 8, -1L);
-		flips |= computeFlips(move, player, opponent, -8, -1L);
-
-		// east & west
-		flips |= computeFlips(move, player, opponent, 1, notAFile);
-		flips |= computeFlips(move, player, opponent, -1, notHFile);
-
-		// north-east & north-west & south-east & south-west
-		flips |= computeFlips(move, player, opponent, 9, notAFile);
-		flips |= computeFlips(move, player, opponent, 7, notHFile);
-		flips |= computeFlips(move, player, opponent, -7, notAFile);
-		flips |= computeFlips(move, player, opponent, -9, notHFile);
-
-		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) {
-					return new PlayResult(GameState.DRAW, -1);
-				}
-
-				return new PlayResult(GameState.WIN, winner);
-			}
-
-			return new PlayResult(GameState.TURN_SKIPPED, getCurrentPlayerIndex());
-		}
-
-		return new PlayResult(GameState.NORMAL, getCurrentPlayerIndex());
-	}
-
-	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;
-        }
-    }
-
-	private long computeMoves(long player, long opponent, int shift, long mask) {
-		long moves = shift(player, shift, mask) & opponent;
-		long captured = moves;
-
-		while (moves != 0) {
-			moves = shift(moves, shift, mask) & opponent;
-			captured |= moves;
-		}
-
-		long landing = shift(captured, shift, mask);
-		return landing & ~(player | opponent);
-	}
-
-	private long computeFlips(long move, long player, long opponent, int shift, long mask) {
-		long flips = 0L;
-		long pos = move;
-
-		while (true) {
-			pos = shift(pos, shift, mask);
-			if (pos == 0) return 0L;
-
-			if ((pos & opponent) != 0) flips |= pos;
-			else if ((pos & player) != 0) return flips;
-			else return 0L;
-		}
-	}
-
-	private long shift(long bit, int shift, long mask) {
-		return shift > 0 ? (bit << shift) & mask : (bit >>> -shift) & mask;
-	}
-
-    public boolean isGameOver(){
-        BitboardReversi copy = this.deepCopy();
-        if (copy.getLegalMoves() == 0){
-            nextTurn();
-            return copy.getLegalMoves() == 0;
-        }
-        return false;
-    }
-}

game/src/main/java/org/toop/game/games/reversi/ReversiAIR.java

@@ -0,0 +1,15 @@
+package org.toop.game.games.reversi;
+
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+
+import java.util.Random;
+
+public final class ReversiAIR extends AbstractAI<ReversiR> {
+	public int getMove(ReversiR game) {
+        int[] moves = game.getLegalMoves();
+        if (moves.length == 0) return -1;
+
+        int inty = new Random().nextInt(0, moves.length);
+		return moves[inty];
+	}
+}

game/src/main/java/org/toop/game/games/reversi/ReversiR.java

@@ -0,0 +1,260 @@
+package org.toop.game.games.reversi;
+
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.model.game.AbstractGame;
+import org.toop.framework.gameFramework.model.player.Player;
+
+import java.awt.*;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.Set;
+
+
+public final class ReversiR extends AbstractGame<ReversiR> {
+    private int movesTaken;
+    private Set<Point> filledCells = new HashSet<>();
+    private int[] mostRecentlyFlippedPieces;
+
+    @Override
+    public ReversiR deepCopy() {
+        return new ReversiR(this);
+    }
+
+    // TODO: Don't hardcore for two players :)
+    public record Score(int player1Score, int player2Score) {}
+
+    public ReversiR(Player<ReversiR>[] players) {
+        super(8, 8, 2, players);
+        addStartPieces();
+    }
+
+    public ReversiR(ReversiR other) {
+        super(other);
+        this.movesTaken = other.movesTaken;
+        this.filledCells = other.filledCells;
+        this.mostRecentlyFlippedPieces = other.mostRecentlyFlippedPieces;
+    }
+
+
+    private void addStartPieces() {
+        this.setBoard(27, 1);
+        this.setBoard(28, 0);
+        this.setBoard(35, 0);
+        this.setBoard(36, 1);
+        updateFilledCellsSet();
+    }
+    private void updateFilledCellsSet() {
+        for (int i = 0; i < 64; i++) {
+            if (this.getBoard()[i] != EMPTY) {
+                filledCells.add(new Point(i % this.getColumnSize(), i / this.getRowSize()));
+            }
+        }
+    }
+
+    @Override
+    public int[] getLegalMoves() {
+        final ArrayList<Integer> legalMoves = new ArrayList<>();
+        int[][] boardGrid = makeBoardAGrid();
+        int currentPlayer = this.getCurrentTurn();
+        Set<Point> adjCell = getAdjacentCells(boardGrid);
+        for (Point point : adjCell){
+            int[] moves = getFlipsForPotentialMove(point,currentPlayer);
+            int score = moves.length;
+            if (score > 0){
+                legalMoves.add(point.x + point.y * this.getRowSize());
+            }
+        }
+        return legalMoves.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    private Set<Point> getAdjacentCells(int[][] boardGrid) {
+        Set<Point> possibleCells = new HashSet<>();
+        for (Point point : filledCells) {                                           //for every filled cell
+            for (int deltaColumn = -1; deltaColumn <= 1; deltaColumn++){            //check adjacent cells
+                for (int deltaRow = -1; deltaRow <= 1; deltaRow++){                 //orthogonally and diagonally
+                    int newX =  point.x + deltaColumn, newY =  point.y + deltaRow;
+                    if (deltaColumn == 0 && deltaRow == 0                           //continue if out of bounds
+                            || !isOnBoard(newX, newY)) {
+                        continue;
+                    }
+                    if (boardGrid[newY][newX] == EMPTY) {                           //check if the cell is empty
+                        possibleCells.add(new Point(newX, newY));                   //and then add it to the set of possible moves
+                    }
+                }
+            }
+        }
+        return possibleCells;
+    }
+
+    public int[] getFlipsForPotentialMove(Point point, int currentPlayer) {
+        final ArrayList<Integer> movesToFlip = new ArrayList<>();
+        for (int deltaColumn = -1; deltaColumn <= 1; deltaColumn++) {               //for all directions
+            for (int deltaRow = -1; deltaRow <= 1; deltaRow++) {
+                if (deltaColumn == 0 && deltaRow == 0){
+                    continue;
+                }
+                int[] moves = getFlipsInDirection(point,makeBoardAGrid(),currentPlayer,deltaColumn,deltaRow);
+                if (moves != null) {                                                //getFlipsInDirection
+                    Arrays.stream(moves).forEach(movesToFlip::add);
+                }
+            }
+        }
+        return movesToFlip.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    private int[] getFlipsInDirection(Point point, int[][] boardGrid, int currentPlayer, int dirX, int dirY) {
+        int opponent = getOpponent(currentPlayer);
+        final ArrayList<Integer> movesToFlip = new ArrayList<>();
+        int x = point.x + dirX;
+        int y = point.y + dirY;
+
+        if (!isOnBoard(x, y) || boardGrid[y][x] != opponent) {                          //there must first be an opponents tile
+            return null;
+        }
+
+        while (isOnBoard(x, y) && boardGrid[y][x] == opponent) {                        //count the opponents tiles in this direction
+
+            movesToFlip.add(x+y*this.getRowSize());
+            x += dirX;
+            y += dirY;
+        }
+        if (isOnBoard(x, y) && boardGrid[y][x] == currentPlayer) {
+            return movesToFlip.stream().mapToInt(Integer::intValue).toArray();                                    //only return the count if last tile is ours
+        }
+        return null;
+    }
+
+    private boolean isOnBoard(int x, int y) {
+        return x >= 0 && x < this.getColumnSize() && y >= 0 && y < this.getRowSize();
+    }
+
+    private int[][] makeBoardAGrid() {
+        int[][] boardGrid = new int[this.getRowSize()][this.getColumnSize()];
+        for (int i = 0; i < 64; i++) {
+            boardGrid[i / this.getRowSize()][i % this.getColumnSize()] = this.getBoard()[i];     //boardGrid[y -> row] [x -> column]
+        }
+        return boardGrid;
+    }
+
+    private boolean gameOver(){
+        ReversiR gameCopy = deepCopy();
+        return gameCopy.getLegalMoves().length == 0 && gameCopy.skipTurn().getLegalMoves().length == 0;
+    }
+
+    @Override
+    public PlayResult play(int move) {
+        /*int[] legalMoves = getLegalMoves();
+        boolean moveIsLegal = false;
+        for (int legalMove : legalMoves) {                         //check if the move is legal
+            if (move == legalMove) {
+                moveIsLegal = true;
+                break;
+            }
+        }
+        if (!moveIsLegal) {
+            return null;
+        }
+
+        int[] moves = sortMovesFromCenter(Arrays.stream(getFlipsForPotentialMove(new Point(move%this.getColumnSize(),move/this.getRowSize()), getCurrentTurn())).boxed().toArray(Integer[]::new),move);
+        mostRecentlyFlippedPieces = moves;
+        this.setBoard(move);                                        //place the move on the board
+        for (int m : moves) {
+            this.setBoard(m);                                       //flip the correct pieces on the board
+        }
+        filledCells.add(new Point(move % this.getRowSize(), move / this.getColumnSize()));
+        nextTurn();
+        if (getLegalMoves().length == 0) {                          //skip the players turn when there are no legal moves
+            skipMyTurn();
+            if (getLegalMoves().length > 0) {
+                return new PlayResult(GameState.TURN_SKIPPED, getCurrentTurn());
+            }
+            else {                                                  //end the game when neither player has a legal move
+                Score score = getScore();
+                if (score.player1Score() == score.player2Score()) {
+                    return new PlayResult(GameState.DRAW, EMPTY);
+                }
+                else {
+                    return new PlayResult(GameState.WIN, getCurrentTurn());
+                }
+            }
+        }
+        return new PlayResult(GameState.NORMAL, EMPTY);*/
+
+        // Check if move is legal
+        if (!contains(getLegalMoves(), move)){
+            // Next person wins
+            return new PlayResult(GameState.WIN, (getCurrentTurn() + 1) % 2);
+        }
+
+        // Move is legal, proceed as normal
+        int[] moves = sortMovesFromCenter(Arrays.stream(getFlipsForPotentialMove(new Point(move%this.getColumnSize(),move/this.getRowSize()), getCurrentTurn())).boxed().toArray(Integer[]::new),move);
+        mostRecentlyFlippedPieces = moves;
+        this.setBoard(move);                                        //place the move on the board
+        for (int m : moves) {
+            this.setBoard(m);                                       //flip the correct pieces on the board
+        }
+        filledCells.add(new Point(move % this.getRowSize(), move / this.getColumnSize()));
+
+        nextTurn();
+
+        // Check for forced turn skip
+        if (getLegalMoves().length == 0){
+            PlayResult result;
+            // Check if next turn is also a force skip
+            if (deepCopy().skipTurn().getLegalMoves().length == 0){
+                // Game over
+                int winner = getWinner();
+                result = new PlayResult(winner == EMPTY ? GameState.DRAW : GameState.WIN, winner);
+            }else{
+                // Turn skipped
+                result = new PlayResult(GameState.TURN_SKIPPED, getCurrentTurn());
+                skipTurn();
+            }
+            return result;
+        }
+        return new PlayResult(GameState.NORMAL, EMPTY);
+    }
+
+    private ReversiR skipTurn(){
+        nextTurn();
+        return this;
+    }
+
+    private int getOpponent(int currentPlayer){
+        return (currentPlayer + 1)%2;
+    }
+
+    public int getWinner(){
+        int player1Score = 0, player2Score = 0;
+        for (int count = 0; count < this.getRowSize() * this.getColumnSize(); count++) {
+            if (this.getBoard()[count] == 0) {
+                player1Score += 1;
+            }
+            if (this.getBoard()[count] == 1) {
+                player2Score += 1;
+            }
+        }
+        return player1Score == player2Score? -1 : player1Score > player2Score ? 0 : 1;
+    }
+    private int[] sortMovesFromCenter(Integer[] moves, int center) {                 //sorts the pieces to be flipped for animation purposes
+        int centerX = center%this.getColumnSize();
+        int centerY = center/this.getRowSize();
+        Arrays.sort(moves, (a, b) -> {
+            int dxA = a%this.getColumnSize() - centerX;
+            int dyA = a/this.getRowSize() - centerY;
+            int dxB = b%this.getColumnSize() - centerX;
+            int dyB = b/this.getRowSize() - centerY;
+
+            int distA = dxA * dxA + dyA * dyA;
+            int distB = dxB * dxB + dyB * dyB;
+
+            return Integer.compare(distA, distB);
+        });
+        return Arrays.stream(moves).mapToInt(Integer::intValue).toArray();
+    }
+    public int[] getMostRecentlyFlippedPieces() {
+        return mostRecentlyFlippedPieces;
+    }
+}

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

@@ -1,103 +0,0 @@
-package org.toop.game.games.tictactoe;
-
-import org.toop.framework.gameFramework.GameState;
-import org.toop.framework.gameFramework.model.game.PlayResult;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.BitboardGame;
-
-public class BitboardTicTacToe extends BitboardGame<BitboardTicTacToe> {
-	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(Player<BitboardTicTacToe>[] players) {
-		super(3, 3, 2, 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){
-            return new PlayResult(GameState.WIN, getNextPlayer());
-        }
-
-        // Move is legal, make move
-		long playerBitboard = getPlayerBitboard(getCurrentPlayerIndex());
-		playerBitboard |= move;
-
-		setPlayerBitboard(getCurrentPlayerIndex(), playerBitboard);
-
-        // Check if current player won
-        if (checkWin(playerBitboard)) {
-            return new PlayResult(GameState.WIN, getCurrentPlayerIndex());
-        }
-
-        // Proceed to next turn
-        nextTurn();
-
-
-        // Check for early draw
-		if (getLegalMoves() == 0L || checkEarlyDraw()) {
-			return new PlayResult(GameState.DRAW, -1);
-		}
-
-        // Nothing weird happened, continue on as normal
-		return new PlayResult(GameState.NORMAL, -1);
-	}
-
-	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);
-    }
-}

game/src/main/java/org/toop/game/games/tictactoe/TicTacToeAIR.java

@@ -0,0 +1,108 @@
+package org.toop.game.games.tictactoe;
+
+import org.toop.framework.gameFramework.model.player.AbstractAI;
+import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.GameState;
+
+/**
+ * AI implementation for playing Tic-Tac-Toe.
+ * <p>
+ * This AI uses a recursive minimax-like strategy with a limited depth to
+ * evaluate moves. It attempts to maximize its chances of winning while
+ * minimizing the opponent's opportunities. Random moves are used in the
+ * opening or when no clear best move is found.
+ * </p>
+ */
+public class TicTacToeAIR extends AbstractAI<TicTacToeR> {
+
+    /**
+     * Determines the best move for the given Tic-Tac-Toe game state.
+     * <p>
+     * Uses a depth-limited recursive strategy to score each legal move and
+     * selects the move with the highest score. If no legal moves are available,
+     * returns -1. If multiple moves are equally good, picks one randomly.
+     * </p>
+     *
+     * @param game  the current Tic-Tac-Toe game state
+     * @param depth the depth of lookahead for evaluating moves (non-negative)
+     * @return the index of the best move, or -1 if no moves are available
+     */
+
+    private int depth;
+
+    public TicTacToeAIR(int depth) {
+        this.depth = depth;
+    }
+
+    public int getMove(TicTacToeR game) {
+        assert game != null;
+        final int[] legalMoves = game.getLegalMoves();
+
+        // If there are no moves, return -1
+        if (legalMoves.length == 0) {
+            return -1;
+        }
+
+        // If first move, pick a corner
+        if (legalMoves.length == 9) {
+            return switch ((int)(Math.random() * 4)) {
+                case 0 -> legalMoves[2];
+                case 1 -> legalMoves[6];
+                case 2 -> legalMoves[8];
+                default -> legalMoves[0];
+            };
+        }
+
+        int bestScore = -depth;
+        int bestMove = -1;
+
+        // Calculate Move score of each move, keep track what moves had the best score
+        for (final int move : legalMoves) {
+            final int score = getMoveScore(game, depth, move, true);
+
+            if (score > bestScore) {
+                bestMove = move;
+                bestScore = score;
+            }
+        }
+        return bestMove != -1 ? bestMove : legalMoves[(int)(Math.random() * legalMoves.length)];
+    }
+
+    /**
+     * Recursively evaluates the score of a potential move using a minimax-like approach.
+     *
+     * @param game       the current Tic-Tac-Toe game state
+     * @param depth      remaining depth to evaluate
+     * @param move       the move to evaluate
+     * @param maximizing true if the AI is to maximize score, false if minimizing
+     * @return the score of the move
+     */
+    private int getMoveScore(TicTacToeR game, int depth, int move, boolean maximizing) {
+        final TicTacToeR copy = game.deepCopy();
+        final PlayResult result = copy.play(move);
+
+        GameState state = result.state();
+
+        switch (state) {
+            case DRAW: return 0;
+            case WIN: return maximizing ? depth + 1 : -depth - 1;
+        }
+
+        if (depth <= 0) {
+            return 0;
+        }
+
+        final int[] legalMoves = copy.getLegalMoves();
+        int score = maximizing ? depth + 1 : -depth - 1;
+
+        for (final int next : legalMoves) {
+            if (maximizing) {
+                score = Math.min(score, getMoveScore(copy, depth - 1, next, false));
+            } else {
+                score = Math.max(score, getMoveScore(copy, depth - 1, next, true));
+            }
+        }
+
+        return score;
+    }
+}

game/src/main/java/org/toop/game/games/tictactoe/TicTacToeAIRSleep.java

@@ -0,0 +1,25 @@
+package org.toop.game.games.tictactoe;
+
+import java.util.Random;
+
+public class TicTacToeAIRSleep extends TicTacToeAIR {
+
+    private int thinkTime;
+
+    public TicTacToeAIRSleep(int depth, int thinkTime) {
+        super(depth);
+        this.thinkTime = thinkTime;
+    }
+
+    @Override
+    public int getMove(TicTacToeR game) {
+        int score = super.getMove(game);
+        try {
+            Random random = new Random();
+            Thread.sleep(this.thinkTime * 1000L +  random.nextInt(1000));
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return score;
+    }
+}

game/src/main/java/org/toop/game/games/tictactoe/TicTacToeR.java

@@ -0,0 +1,118 @@
+package org.toop.game.games.tictactoe;
+
+import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.model.game.AbstractGame;
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.player.Player;
+
+import java.util.ArrayList;
+import java.util.Objects;
+
+public final class TicTacToeR extends AbstractGame<TicTacToeR> {
+    private int movesLeft;
+
+    public TicTacToeR(Player<TicTacToeR>[] players) {
+        super(3, 3, 2, players);
+        movesLeft = this.getBoard().length;
+    }
+
+    public TicTacToeR(TicTacToeR other) {
+        super(other);
+        movesLeft = other.movesLeft;
+    }
+
+    @Override
+    public int[] getLegalMoves() {
+        final ArrayList<Integer> legalMoves = new ArrayList<Integer>();
+
+        for (int i = 0; i < this.getBoard().length; i++) {
+            if (Objects.equals(this.getBoard()[i], EMPTY)) {
+                legalMoves.add(i);
+            }
+        }
+        return legalMoves.stream().mapToInt(Integer::intValue).toArray();
+    }
+
+    @Override
+    public PlayResult play(int move) {
+        // NOT MY ASSERTIONS - Stef
+        assert move >= 0 && move < this.getBoard().length;
+
+        // Player loses if move is invalid
+        if (!contains(getLegalMoves(), move)) {
+            // Next player wins
+            return new PlayResult(GameState.WIN, (getCurrentTurn() + 1)%2); // TODO: Make this a generic method like getNextPlayer() or something similar.
+        }
+
+        // Move is valid, make move.
+        this.setBoard(move);
+        movesLeft--;
+        nextTurn();
+
+        // Check if current player won TODO: Make this generic?
+        // Not sure why I am checking for ANY win when only current player should be able to win.
+        int t = checkForWin();
+        if (t != EMPTY) {
+            return new PlayResult(GameState.WIN, t);
+        }
+
+        // Check for (early) draw
+        if (movesLeft <= 3) {
+            if (checkForEarlyDraw()) {
+                return new PlayResult(GameState.DRAW, EMPTY);
+            }
+        }
+
+        // Nothing weird happened, continue on as normal
+        return new PlayResult(GameState.NORMAL, EMPTY);
+    }
+
+    private int checkForWin() {
+        // Horizontal
+        for (int i = 0; i < 3; i++) {
+
+            final int index = i * 3;
+
+            if (!Objects.equals(this.getBoard()[index], EMPTY)
+                    && Objects.equals(this.getBoard()[index], this.getBoard()[index + 1])
+                    && Objects.equals(this.getBoard()[index], this.getBoard()[index + 2])) {
+                return this.getBoard()[index];
+            }
+        }
+
+        // Vertical
+        for (int i = 0; i < 3; i++) {
+            if (!Objects.equals(this.getBoard()[i], EMPTY) && Objects.equals(this.getBoard()[i], this.getBoard()[i + 3]) && Objects.equals(this.getBoard()[i], this.getBoard()[i + 6])) {
+                return this.getBoard()[i];
+            }
+        }
+
+        // B-Slash
+        if (!Objects.equals(this.getBoard()[0], EMPTY) && Objects.equals(this.getBoard()[0], this.getBoard()[4]) && Objects.equals(this.getBoard()[0], this.getBoard()[8])) {
+            return this.getBoard()[0];
+        }
+
+        // F-Slash
+        if (!Objects.equals(this.getBoard()[2], EMPTY) && Objects.equals(this.getBoard()[2], this.getBoard()[4]) && Objects.equals(this.getBoard()[2], this.getBoard()[6]))
+            return this.getBoard()[2];
+
+        // Default return
+        return EMPTY;
+    }
+
+    private boolean checkForEarlyDraw() {
+        for (final int move : this.getLegalMoves()) {
+            final TicTacToeR copy = this.deepCopy();
+
+            if (copy.play(move).state() == GameState.WIN || !copy.checkForEarlyDraw()) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+
+    public TicTacToeR deepCopy() {
+        return new TicTacToeR(this);
+    }
+}

game/src/main/java/org/toop/game/machinelearning/NeuralNetwork.java

@@ -1,228 +0,0 @@
-package org.toop.game.machinelearning;
-
-import org.deeplearning4j.nn.conf.MultiLayerConfiguration;
-import org.deeplearning4j.nn.conf.NeuralNetConfiguration;
-import org.deeplearning4j.nn.conf.layers.DenseLayer;
-import org.deeplearning4j.nn.conf.layers.OutputLayer;
-import org.deeplearning4j.nn.multilayer.MultiLayerNetwork;
-import org.deeplearning4j.nn.weights.WeightInit;
-import org.deeplearning4j.util.ModelSerializer;
-import org.nd4j.linalg.activations.Activation;
-import org.nd4j.linalg.api.ndarray.INDArray;
-import org.nd4j.linalg.dataset.DataSet;
-import org.nd4j.linalg.factory.Nd4j;
-import org.nd4j.linalg.learning.config.Adam;
-import org.nd4j.linalg.lossfunctions.LossFunctions;
-import org.toop.framework.gameFramework.GameState;
-import org.toop.framework.gameFramework.model.game.PlayResult;
-import org.toop.framework.gameFramework.model.player.AbstractAI;
-import org.toop.framework.gameFramework.model.player.Player;
-import org.toop.game.games.reversi.BitboardReversi;
-import org.toop.game.players.ArtificialPlayer;
-import org.toop.game.players.ai.MiniMaxAI;
-import org.toop.game.players.ai.RandomAI;
-import org.toop.game.players.ai.ReversiAIML;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-import static java.lang.Math.abs;
-import static java.lang.Math.random;
-
-public class NeuralNetwork {
-
-    private MultiLayerConfiguration conf;
-    private MultiLayerNetwork model;
-    private AbstractAI<BitboardReversi> opponentAI;
-    private AbstractAI<BitboardReversi> opponentMM = new MiniMaxAI<>(6);
-    private AbstractAI<BitboardReversi> opponentRand = new RandomAI<>();
-    private AbstractAI<BitboardReversi> opponentAIML = new ReversiAIML<>();
-    private Player[] playerSet = new Player[4];
-
-
-    public NeuralNetwork() {}
-
-    public void init(){
-        initPlayers();
-
-        conf = new NeuralNetConfiguration.Builder()
-                .updater(new Adam(0.001))
-                .weightInit(WeightInit.XAVIER) //todo understand
-                .list()
-                .layer(new DenseLayer.Builder()
-                        .nIn(64)
-                        .nOut(128)
-                        .activation(Activation.RELU)
-                        .build())
-                .layer(new OutputLayer.Builder(LossFunctions.LossFunction.MCXENT)
-                        .nIn(128)
-                        .nOut(64)
-                        .activation(Activation.SOFTMAX)
-                        .build())
-                .build();
-        model = new MultiLayerNetwork(conf);
-        IO.println(model.params());
-        loadModel();
-        IO.println(model.params());
-        model.init();
-        IO.println(model.summary());
-
-        model.setLearningRate(0.0003);
-        trainingLoop();
-        saveModel();
-    }
-
-    public void initPlayers(){
-        playerSet[0] = new ArtificialPlayer<>(new MiniMaxAI<BitboardReversi>(6),"MiniMaxAI");
-        playerSet[1] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(),"RandomAI");
-        playerSet[2] = new ArtificialPlayer<>(new ReversiAIML<BitboardReversi>(),"MachineLearningAI");
-    }
-
-    public void saveModel(){
-        File modelFile = new File("reversi-model.zip");
-        try {
-            ModelSerializer.writeModel(model, modelFile, true);
-        }catch (Exception e){
-            e.printStackTrace();
-        }
-    }
-
-    public void loadModel(){
-        File modelFile = new File("reversi-model.zip");
-        try {
-            model = ModelSerializer.restoreMultiLayerNetwork(modelFile);
-        } catch (IOException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public void trainingLoop(){
-        int totalGames = 5000;
-        double epsilon = 0.05;
-
-
-
-        long start =  System.nanoTime();
-
-        for (int game = 0; game<totalGames; game++){
-            char modelPlayer = random()<0.5?'B':'W';
-            BitboardReversi reversi = new BitboardReversi(new Player[2]);
-            opponentAI = getOpponentAI();
-            List<StateAction> gameHistory = new ArrayList<>();
-            PlayResult state = new PlayResult(GameState.NORMAL,reversi.getCurrentTurn());
-
-            double reward = 0;
-
-            while (state.state() != GameState.DRAW && state.state() != GameState.WIN){
-                int curr = reversi.getCurrentTurn();
-                long move;
-                if (curr == modelPlayer) {
-                    long[] input = reversi.getBoard();
-                    if (Math.random() < epsilon) {
-                        long moves = reversi.getLegalMoves();
-                        move = (long) (Math.random() * Long.bitCount(moves) - .5f);
-                    } else {
-                        INDArray boardInput = Nd4j.create(new long[][]{input});
-                        INDArray prediction = model.output(boardInput);
-
-                        int location = pickLegalMove(prediction, reversi);
-                        gameHistory.add(new StateAction(input, location));
-                        move = location;
-                    }
-                }else{
-                    move = opponentAI.getMove(reversi);
-                }
-                state = reversi.play(move);
-            }
-
-            //IO.println(model.params());
-            BitboardReversi.Score score = reversi.getScore();
-            int scoreDif = abs(score.black() - score.white());
-            if (score.black() > score.white()){
-                reward = 1 + ((scoreDif / 64.0) * 0.5);
-            }else if (score.black() < score.white()){
-                reward = -1 - ((scoreDif / 64.0) * 0.5);
-            }else{
-                reward = 0;
-            }
-
-            if (modelPlayer == 'W'){
-                reward = -reward;
-            }
-
-
-            for (StateAction step : gameHistory){
-                trainFromHistory(step, reward);
-            }
-
-            //IO.println("Wr: " + (double)p1wins/(game+1) + " draws: " + draws);
-            if(game % 100 == 0){
-                IO.println("Completed game " + game + " | Reward: " + reward);
-                //IO.println(Arrays.toString(reversi.getBoardDouble()));
-            }
-        }
-        long end  =  System.nanoTime();
-        IO.println((end-start));
-    }
-
-
-    private int pickLegalMove(INDArray prediction, BitboardReversi reversi) {
-        double[] logits = prediction.toDoubleVector();
-        long legalMoves = reversi.getLegalMoves();
-
-        if (legalMoves == 0L) {
-            return -1;
-        }
-
-        if (Math.random() < 0.01) {
-            int randomIndex = (int) (Math.random() * Long.bitCount(legalMoves));
-            long moves = legalMoves;
-            for (int i = 0; i < randomIndex; i++) {
-                moves &= moves - 1;
-            }
-            return Long.numberOfTrailingZeros(moves);
-        }
-
-        int bestMove = -1;
-        double bestVal = Double.NEGATIVE_INFINITY;
-
-        long moves = legalMoves;
-        while (moves != 0L) {
-            int move = Long.numberOfTrailingZeros(moves);
-            double value = logits[move];
-
-            if (value > bestVal) {
-                bestVal = value;
-                bestMove = move;
-            }
-
-            moves &= moves - 1;
-        }
-
-        return bestMove;
-    }
-
-    private AbstractAI<BitboardReversi> getOpponentAI(){
-        return switch ((int) (Math.random() * 4)) {
-            case 0 -> opponentRand;
-            case 1 -> opponentMM;
-            case 2 -> opponentAIML;
-            default -> opponentRand;
-        };
-    }
-
-    private void trainFromHistory(StateAction step, double reward){
-        double[] output = new double[64];
-        output[step.action] = reward;
-
-        DataSet ds = new DataSet(
-                Nd4j.create(new long[][] { step.state }),
-                Nd4j.create(new double[][] { output })
-        );
-
-        model.fit(ds);
-
-    }
-}

game/src/main/java/org/toop/game/machinelearning/StateAction.java

@@ -1,10 +0,0 @@
-package org.toop.game.machinelearning;
-
-public class StateAction {
-    long[] state;
-    int action;
-    public StateAction(long[] state, int action) {
-        this.state = state;
-        this.action = action;
-    }
-}

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

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

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

@@ -6,82 +6,70 @@ 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<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+    // Future can be used with event system, IF unsubscribeAfterSuccess works...
+    // private CompletableFuture<Integer> LastMove = new CompletableFuture<>();
 
-    private CompletableFuture<Long> LastMove = new CompletableFuture<>();
+    private CompletableFuture<Integer> LastMove;
 
-    /**
-     * 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<T> 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(T gameCopy) {
-        long legalMoves = gameCopy.getLegalMoves();
-        long move;
-
-        do {
-            move = getLastMove();
-        } while ((legalMoves & move) == 0);
-
-        return move;
+    public int getMove(T gameCopy) {
+        return getValidMove(gameCopy);
     }
 
-    /**
-     * Sets the player's last move.
-     *
-     * @param move the move to set
-     */
-    public void setLastMove(long move) {
+    public void setMove(int 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;
-        }
+    // TODO: helper function, would like to replace to get rid of this method
+    public static boolean contains(int[] array, int value){
+        for (int i : array) if (i == value) return true;
+        return false;
     }
 
-    /**
-     * Creates a deep copy of this local player.
-     *
-     * @return a copy of this player
-     */
-    @Override
-    public LocalPlayer<T> deepCopy() {
-        return new LocalPlayer<>(this);
+    private int getMove2(T gameCopy) {
+        LastMove = new CompletableFuture<>();
+        int move = -1;
+        try {
+            move = LastMove.get();
+        } catch (InterruptedException | ExecutionException e) {
+            // TODO: Add proper logging.
+            e.printStackTrace();
+        }
+        return move;
     }
+
+    protected int getValidMove(T gameCopy){
+        // Get this player's valid moves
+        int[] validMoves = gameCopy.getLegalMoves();
+        // Make sure provided move is valid
+        // TODO: Limit amount of retries?
+        // TODO: Stop copying game so many times
+        int move = getMove2(gameCopy.deepCopy());
+        while (!contains(validMoves, move)) {
+            System.out.println("Not a valid move, try again");
+            move = getMove2(gameCopy.deepCopy());
+        }
+        return move;
+    }
+
+    /*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;
+    }*/
 }