Loading circle, better loading colors.

* Cleaned up a lot of old files and renamed/remade interfaces to better suit the framework

* Broken commit

* Fixed online play

* Better file structure and closer to MVC

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

@@ -11,30 +11,6 @@ import org.toop.framework.resource.resources.SoundEffectAsset;
 
 public final class Main {
     static void main(String[] args) {
-        initSystems();
         App.run(args);
     }
-
-    private static void initSystems() {
-        ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets"));
-        new Thread(() -> new NetworkingClientEventListener(new NetworkingClientManager())).start();
-
-        new Thread(() -> {
-            MusicManager<MusicAsset> musicManager = new MusicManager<>(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<>(
-                musicManager,
-                soundEffectManager,
-                audioVolumeManager
-            ).initListeners("medium-button-click.wav");
-
-        }).start();
-    }
-
 }

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

@@ -1,13 +1,26 @@
 package org.toop.app;
 
+import javafx.application.Platform;
+import javafx.scene.paint.Color;
+import org.toop.Main;
+import org.toop.app.widget.Primitive;
+import org.toop.app.widget.Widget;
 import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.LoadingWidget;
 import org.toop.app.widget.display.SongDisplay;
 import org.toop.app.widget.popup.QuitPopup;
 import org.toop.app.widget.view.MainView;
+import org.toop.framework.audio.*;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.networking.NetworkingClientEventListener;
+import org.toop.framework.networking.NetworkingClientManager;
+import org.toop.framework.resource.ResourceLoader;
 import org.toop.framework.resource.ResourceManager;
+import org.toop.framework.resource.events.AssetLoaderEvents;
 import org.toop.framework.resource.resources.CssAsset;
+import org.toop.framework.resource.resources.MusicAsset;
+import org.toop.framework.resource.resources.SoundEffectAsset;
 import org.toop.local.AppContext;
 import org.toop.local.AppSettings;
 
@@ -32,14 +45,20 @@ public final class App extends Application {
 
 	@Override
 	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"));
+
         final StackPane root = WidgetContainer.setup();
 		final Scene scene = new Scene(root);
 
+		stage.setOpacity(0.0);
+
 		stage.setTitle(AppContext.getString("app-title"));
 		stage.titleProperty().bind(AppContext.bindToKey("app-title"));
 
-		stage.setWidth(1080);
-		stage.setHeight(720);
+		stage.setWidth(0);
+		stage.setHeight(0);
 
 		scene.getRoot();
 
@@ -47,14 +66,12 @@ public final class App extends Application {
         stage.setMinHeight(720);
 		stage.setOnCloseRequest(event -> {
 			event.consume();
-			startQuit();
+			quit();
 		});
 
 		stage.setScene(scene);
 		stage.setResizable(true);
 
-		stage.show();
-
 		App.stage = stage;
 		App.scene = scene;
 
@@ -64,10 +81,100 @@ public final class App extends Application {
 		App.isQuitting = false;
 
 		AppSettings.applySettings();
-		new EventFlow().addPostEvent(new AudioEvents.StartBackgroundMusic()).asyncPostEvent();
 
+        LoadingWidget loading = new LoadingWidget(Primitive.text(
+                "Loading...", false), 0, 0, Integer.MAX_VALUE, false, false // Just set a high default
+        );
+
+		WidgetContainer.setCurrentView(loading);
+
+		setOnLoadingSuccess(loading);
+
+        EventFlow loadingFlow = new EventFlow();
+
+		final boolean[] hasRun = {false};
+        loadingFlow
+                .listen(AssetLoaderEvents.LoadingProgressUpdate.class, e -> {
+					if (!hasRun[0]) {
+						hasRun[0] = true;
+						try {
+							Thread.sleep(100);
+						} catch (InterruptedException ex) {
+							throw new RuntimeException(ex);
+						}
+						Platform.runLater(() -> stage.setOpacity(1.0));
+					}
+
+					Platform.runLater(() -> loading.setMaxAmount(e.isLoadingAmount()));
+
+					Platform.runLater(() -> {
+						try {
+							loading.setAmount(e.hasLoadedAmount());
+						} catch (Exception ex) {
+							throw new RuntimeException(ex);
+						}
+					});
+
+                    if (e.hasLoadedAmount() >= e.isLoadingAmount()) {
+                        Platform.runLater(loading::triggerSuccess);
+                        loadingFlow.unsubscribe("init_loading");
+                    }
+
+                }, false, "init_loading");
+
+		// Start loading assets
+		new Thread(() -> ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets")))
+				.start();
+
+		stage.show();
+
+	}
+
+	private void setOnLoadingSuccess(LoadingWidget loading) {
+		loading.setOnSuccess(() -> {
+			initSystems();
+			AppSettings.applyMusicVolumeSettings();
+			new EventFlow().addPostEvent(new AudioEvents.StartBackgroundMusic()).postEvent();
+            loading.hide();
 			WidgetContainer.add(Pos.CENTER, new MainView());
 			WidgetContainer.add(Pos.BOTTOM_RIGHT, new SongDisplay());
+			stage.setOnCloseRequest(event -> {
+				event.consume();
+				startQuit();
+			});
+		});
+	}
+
+	private void initSystems() { // TODO Move to better place
+		new Thread(() -> new NetworkingClientEventListener(new NetworkingClientManager())).start();
+
+		new Thread(() -> {
+			MusicManager<MusicAsset> musicManager =
+					new MusicManager<>(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<>(
+					musicManager,
+					soundEffectManager,
+					audioVolumeManager
+			).initListeners("medium-button-click.wav");
+
+		}).start();
+
+		// Threads must be ready, before continue, TODO use latch instead
+        try {
+            Thread.sleep(200);
+        } catch (InterruptedException e) {
+            throw new RuntimeException(e);
+        }
     }
 
 	public static void startQuit() {

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

@@ -3,9 +3,7 @@ package org.toop.app;
 public class GameInformation {
 	public enum Type {
 		TICTACTOE(2, 5),
-		REVERSI(2, 10),
-        CONNECT4(2, 7),
-        BATTLESHIP(2, 5);
+		REVERSI(2, 10);
 
         private final int playerCount;
         private final int maxDepth;

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

@@ -1,17 +1,27 @@
 package org.toop.app;
 
-import org.toop.app.game.Connect4Game;
-import org.toop.app.game.ReversiGame;
-import org.toop.app.game.TicTacToeGame;
+import javafx.application.Platform;
+import javafx.geometry.Pos;
+import org.toop.app.gameControllers.AbstractGameController;
+import org.toop.app.gameControllers.ReversiController;
+import org.toop.app.gameControllers.TicTacToeController;
+import org.toop.app.widget.Primitive;
 import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.LoadingWidget;
 import org.toop.app.widget.popup.ChallengePopup;
 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.model.player.Player;
 import org.toop.framework.networking.clients.TournamentNetworkingClient;
 import org.toop.framework.networking.events.NetworkEvents;
 import org.toop.framework.networking.types.NetworkingConnector;
+import org.toop.game.players.ArtificialPlayer;
+import org.toop.game.players.OnlinePlayer;
+import org.toop.game.games.reversi.ReversiAIR;
+import org.toop.game.games.reversi.ReversiR;
+import org.toop.game.games.tictactoe.TicTacToeAIR;
 import org.toop.local.AppContext;
 
 import java.util.List;
@@ -22,6 +32,7 @@ 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;
 
@@ -31,24 +42,27 @@ public final class Server {
 	private ServerView primary;
 	private boolean isPolling = true;
 
+    private AbstractGameController<?> gameController;
+
     private final AtomicBoolean isSingleGame = new AtomicBoolean(false);
 
 	private ScheduledExecutorService scheduler;
 
+    private EventFlow eventFlow = new EventFlow();
+
 	public static GameInformation.Type gameToType(String game) {
 		if (game.equalsIgnoreCase("tic-tac-toe")) {
 			return GameInformation.Type.TICTACTOE;
 		} else if (game.equalsIgnoreCase("reversi")) {
 			return GameInformation.Type.REVERSI;
-		} else if (game.equalsIgnoreCase("connect4")) {
-			return GameInformation.Type.CONNECT4;
-//		} else if (game.equalsIgnoreCase("battleship")) {
-//			return GameInformation.Type.BATTLESHIP;
 		}
 
 		return null;
 	}
 
+
+    // Server has to deal with ALL network related listen events. This "server" can then interact with the manager to make stuff happen.
+    // This prevents data races where events get sent to the game manager but the manager isn't ready yet.
 	public Server(String ip, String port, String user) {
 		if (ip.split("\\.").length < 4) {
 			new ErrorPopup("\"" + ip + "\" " + AppContext.getString("is-not-a-valid-ip-address"));
@@ -69,12 +83,41 @@ public final class Server {
 			return;
 		}
 
-		new EventFlow()
+		final int reconnectAttempts = 10;
+
+		LoadingWidget loading = new LoadingWidget(
+                Primitive.text("connecting"), 0, 0, reconnectAttempts, true, true
+        );
+
+		WidgetContainer.getCurrentView().transitionNext(loading);
+
+		var a = new EventFlow()
 			.addPostEvent(NetworkEvents.StartClient.class,
 				new TournamentNetworkingClient(),
-				new NetworkingConnector(ip, parsedPort, 10, 1, TimeUnit.SECONDS)
-			)
-			.onResponse(NetworkEvents.StartClientResponse.class, e -> {
+				new NetworkingConnector(ip, parsedPort, reconnectAttempts, 1, TimeUnit.SECONDS)
+			);
+
+        loading.setOnFailure(() -> {
+            WidgetContainer.getCurrentView().transitionPrevious();
+            a.unsubscribe("connecting");
+			a.unsubscribe("startclient");
+            WidgetContainer.add(
+                    Pos.CENTER,
+                    new ErrorPopup(AppContext.getString("connecting-failed") + " " + ip + ":" + port)
+            );
+        });
+
+		a.onResponse(NetworkEvents.StartClientResponse.class, e -> {
+
+			if (!e.successful()) {
+				return;
+			}
+
+			WidgetContainer.getCurrentView().transitionPrevious();
+
+			a.unsubscribe("connecting");
+			a.unsubscribe("startclient");
+
 			this.user = user;
 			clientId = e.clientId();
 
@@ -85,11 +128,30 @@ public final class Server {
 
 			startPopulateScheduler();
 			populateGameList();
+		}, false, "startclient")
+				.listen(
+                        NetworkEvents.ConnectTry.class,
+                        e -> Platform.runLater(
+                                () -> {
+                                    try {
+                                        loading.setAmount(e.amount());
+                                        if (e.amount() >= loading.getMaxAmount()) {
+                                            loading.triggerFailure();
+                                        }
+                                    } catch (Exception ex) {
+                                        throw new RuntimeException(ex);
+                                    }
+                                }
+                        ),
+                        false, "connecting"
+                )
+				.postEvent();
 
-			}).postEvent();
-
-		new EventFlow().listen(this::handleReceivedChallenge)
-                .listen(this::handleMatchResponse);
+		eventFlow.listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false)
+                .listen(NetworkEvents.GameMatchResponse.class, this::handleMatchResponse, false)
+                .listen(NetworkEvents.GameResultResponse.class, this::handleGameResult, false)
+                .listen(NetworkEvents.GameMoveResponse.class, this::handleReceivedMove, false)
+                .listen(NetworkEvents.YourTurnResponse.class, this::handleYourTurn, false);
 	}
 
 	private void sendChallenge(String opponent) {
@@ -102,10 +164,16 @@ public final class Server {
 	}
 
     private void handleMatchResponse(NetworkEvents.GameMatchResponse response) {
-        if (!isPolling) return;
+        // TODO: Redo all of this mess
+        if (gameController != null) {
+            gameController.stop();
+        }
+
+        gameController = null;
+
+        //if (!isPolling) return;
 
         String gameType = extractQuotedValue(response.gameType());
-
         if (response.clientId() == clientId) {
             isPolling = false;
             onlinePlayers.clear();
@@ -126,20 +194,55 @@ public final class Server {
             information.players[0].computerThinkTime = 1;
             information.players[1].name = response.opponent();
 
-            Runnable onGameOverRunnable = isSingleGame.get()? null: this::gameOver;
+            Player[] players = new Player[2];
 
+            players[(myTurn + 1) % 2] = new OnlinePlayer<ReversiR>(response.opponent());
 
             switch (type){
-                case TICTACTOE ->
-                        new TicTacToeGame(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
+                case TICTACTOE ->{
+                    players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(), user);
+                }
+                case REVERSI ->{
+                    players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
+                }
+            }
+
+            switch (type) {
+                case TICTACTOE ->{
+                        gameController = new TicTacToeController(players, false);
+                }
                 case REVERSI ->
-                        new ReversiGame(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
-                case CONNECT4 ->
-                        new Connect4Game(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
+                        gameController = new ReversiController(players, false);
                 default -> new ErrorPopup("Unsupported game type.");
             }
+
+            if (gameController != null){
+                gameController.start();
             }
         }
+    }
+
+    private void handleYourTurn(NetworkEvents.YourTurnResponse response) {
+        if (gameController == null) {
+            return;
+        }
+        gameController.onYourTurn(response);
+
+    }
+
+    private void handleGameResult(NetworkEvents.GameResultResponse response) {
+        if (gameController == null) {
+            return;
+        }
+        gameController.gameFinished(response);
+    }
+
+    private void handleReceivedMove(NetworkEvents.GameMoveResponse response) {
+        if (gameController == null) {
+            return;
+        }
+        gameController.onMoveReceived(response);
+    }
 
 	private void handleReceivedChallenge(NetworkEvents.ChallengeResponse response) {
         if (!isPolling) return;
@@ -200,7 +303,7 @@ public final class Server {
 			} else {
 				stopScheduler();
 			}
-		}, 0, 5, TimeUnit.SECONDS);
+		}, 0, 1, TimeUnit.SECONDS);
 	}
 
 	private void stopScheduler() {

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

@@ -1,6 +1,7 @@
 package org.toop.app.canvas;
 
 import javafx.scene.paint.Color;
+import org.toop.framework.gameFramework.model.game.AbstractGame;
 
 import java.util.function.Consumer;
 
@@ -8,4 +9,9 @@ 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

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

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

@@ -0,0 +1,5 @@
+package org.toop.app.canvas;
+
+public interface DrawPlayerMove {
+    void drawPlayerMove(int player, int move);
+}

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

@@ -6,12 +6,13 @@ import javafx.scene.canvas.Canvas;
 import javafx.scene.canvas.GraphicsContext;
 import javafx.scene.input.MouseButton;
 import javafx.scene.paint.Color;
+import javafx.scene.text.Font;
 import javafx.util.Duration;
+import org.toop.framework.gameFramework.model.game.AbstractGame;
 
-import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Consumer;
 
-public abstract class GameCanvas {
+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 &&
@@ -36,10 +37,18 @@ public abstract class GameCanvas {
 
 	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;
 
@@ -78,7 +87,7 @@ public abstract class GameCanvas {
 
 			if (cell.isInside(event.getX(), event.getY())) {
 				event.consume();
-				onCellClicked.accept(column + row * rowSize);
+				this.onCellCLicked.accept(column + row * rowSize);
 			}
 		});
 
@@ -143,6 +152,19 @@ public abstract class GameCanvas {
 		}
 	}
 
+    @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;

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

@@ -1,12 +1,14 @@
 package org.toop.app.canvas;
 
 import javafx.scene.paint.Color;
-import org.toop.game.records.Move;
+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 {
+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);
@@ -81,4 +83,14 @@ public final class ReversiCanvas extends GameCanvas {
         }
         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/TicTacToeCanvas.java

@@ -1,14 +1,25 @@
 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 {
+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);
@@ -35,4 +46,9 @@ public final class TicTacToeCanvas extends GameCanvas {
 
 		graphics.strokeOval(x, y, width, height);
 	}
+
+    @Override
+    public void drawPlayerHover(int player, int move, AbstractGame game) {
+
+    }
 }

app/src/main/java/org/toop/app/game/BaseGameThread.java

@@ -1,122 +0,0 @@
-package org.toop.app.game;
-
-import org.toop.app.GameInformation;
-import org.toop.app.widget.WidgetContainer;
-import org.toop.app.widget.view.GameView;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.Game;
-import org.toop.game.records.Move;
-
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
-import java.util.function.Function;
-import java.util.function.Supplier;
-
-public abstract class BaseGameThread<TGame extends Game, TAI, TCanvas> {
-	protected final GameInformation information;
-	protected final int myTurn;
-	protected final Runnable onGameOver;
-	protected final BlockingQueue<Move> moveQueue;
-
-	protected final TGame game;
-	protected final TAI ai;
-
-	protected final GameView primary;
-	protected final TCanvas canvas;
-
-	protected final AtomicBoolean isRunning = new AtomicBoolean(true);
-
-	protected BaseGameThread(
-		GameInformation information,
-		int myTurn,
-		Runnable onForfeit,
-		Runnable onExit,
-		Consumer<String> onMessage,
-		Runnable onGameOver,
-		Supplier<TGame> gameSupplier,
-		Supplier<TAI> aiSupplier,
-		Function<Consumer<Integer>, TCanvas> canvasFactory) {
-
-		this.information = information;
-		this.myTurn = myTurn;
-		this.onGameOver = onGameOver;
-		this.moveQueue = new LinkedBlockingQueue<>();
-
-		this.game = gameSupplier.get();
-		this.ai = aiSupplier.get();
-
-        String type = information.type.getTypeToString();
-        if (onForfeit == null || onExit == null) {
-            primary = new GameView(null, () -> {
-                isRunning.set(false);
-                WidgetContainer.getCurrentView().transitionPrevious();
-            }, null, type);
-		} else {
-			primary = new GameView(onForfeit, () -> {
-				isRunning.set(false);
-				onExit.run();
-			}, onMessage, type);
-		}
-
-		this.canvas = canvasFactory.apply(this::onCellClicked);
-
-		addCanvasToPrimary();
-
-		WidgetContainer.getCurrentView().transitionNext(primary);
-
-		if (onForfeit == null || onExit == null)
-			new Thread(this::localGameThread).start();
-		else
-			new EventFlow()
-				.listen(NetworkEvents.GameMoveResponse.class, this::onMoveResponse)
-				.listen(NetworkEvents.YourTurnResponse.class, this::onYourTurnResponse);
-
-		setGameLabels(myTurn == 0);
-	}
-
-	private void onCellClicked(int cell) {
-		if (!isRunning.get()) return;
-
-		final int currentTurn = getCurrentTurn();
-		if (!information.players[currentTurn].isHuman) return;
-
-		final char value = getSymbolForTurn(currentTurn);
-
-		try {
-			moveQueue.put(new Move(cell, value));
-		} catch (InterruptedException _) {}
-	}
-
-	protected void gameOver() {
-		if (onGameOver != null) {
-			isRunning.set(false);
-			onGameOver.run();
-		}
-	}
-
-	protected void setGameLabels(boolean isMe) {
-		final int currentTurn = getCurrentTurn();
-		final String turnName = getNameForTurn(currentTurn);
-
-		primary.nextPlayer(
-			isMe,
-			information.players[isMe ? 0 : 1].name,
-			turnName,
-			information.players[isMe ? 1 : 0].name
-		);
-	}
-
-	protected abstract void addCanvasToPrimary();
-
-	protected abstract int getCurrentTurn();
-	protected abstract char getSymbolForTurn(int turn);
-	protected abstract String getNameForTurn(int turn);
-
-	protected abstract void onMoveResponse(NetworkEvents.GameMoveResponse response);
-	protected abstract void onYourTurnResponse(NetworkEvents.YourTurnResponse response);
-
-	protected abstract void localGameThread();
-}

app/src/main/java/org/toop/app/game/Connect4Game.java

@@ -1,265 +0,0 @@
-package org.toop.app.game;
-
-import javafx.geometry.Pos;
-import javafx.scene.paint.Color;
-import org.toop.app.App;
-import org.toop.app.GameInformation;
-import org.toop.app.canvas.Connect4Canvas;
-import org.toop.app.widget.view.GameView;
-import org.toop.app.widget.WidgetContainer;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.Connect4.Connect4;
-import org.toop.game.Connect4.Connect4AI;
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
-
-public class Connect4Game {
-    private final GameInformation information;
-
-    private final int myTurn;
-    private Runnable onGameOver;
-    private final BlockingQueue<Move> moveQueue;
-
-    private final Connect4 game;
-    private final Connect4AI ai;
-    private final int columnSize = 7;
-    private final int rowSize = 6;
-
-    private final GameView primary;
-    private final Connect4Canvas canvas;
-
-    private final AtomicBoolean isRunning;
-
-    public Connect4Game(GameInformation information, int myTurn, Runnable onForfeit, Runnable onExit, Consumer<String> onMessage, Runnable onGameOver) {
-        this.information = information;
-        this.myTurn = myTurn;
-        this.onGameOver = onGameOver;
-        moveQueue = new LinkedBlockingQueue<Move>();
-
-
-        game = new Connect4();
-        ai = new Connect4AI();
-
-        isRunning = new AtomicBoolean(true);
-
-        if (onForfeit == null || onExit == null) {
-            primary = new GameView(null, () -> {
-                isRunning.set(false);
-                WidgetContainer.getCurrentView().transitionPrevious();
-            }, null, "Connect4");
-        } else {
-            primary = new GameView(onForfeit, () -> {
-                isRunning.set(false);
-                onExit.run();
-            }, onMessage, "Connect4");
-        }
-
-        canvas = new Connect4Canvas(Color.GRAY,
-                (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,
-                (cell) -> {
-                    if (onForfeit == null || onExit == null) {
-                        if (information.players[game.getCurrentTurn()].isHuman) {
-                            final char value = game.getCurrentTurn() == 0? 'X' : 'O';
-
-                            try {
-                                moveQueue.put(new Move(cell%columnSize, value));
-                            } catch (InterruptedException _) {}
-                        }
-                    } else {
-                        if (information.players[0].isHuman) {
-                            final char value = myTurn == 0? 'X' : 'O';
-
-                            try {
-                                moveQueue.put(new Move(cell%columnSize, value));
-                            } catch (InterruptedException _) {}
-                        }
-                    }
-                });
-
-        primary.add(Pos.CENTER, canvas.getCanvas());
-        WidgetContainer.getCurrentView().transitionNext(primary);
-
-        if (onForfeit == null || onExit == null) {
-            new Thread(this::localGameThread).start();
-			setGameLabels(information.players[0].isHuman);
-        } else {
-            new EventFlow()
-                    .listen(NetworkEvents.GameMoveResponse.class, this::onMoveResponse)
-                    .listen(NetworkEvents.YourTurnResponse.class, this::onYourTurnResponse);
-
-            setGameLabels(myTurn == 0);
-        }
-        updateCanvas();
-    }
-
-    public Connect4Game(GameInformation information) {
-        this(information, 0, null, null, null, null);
-    }
-    private void localGameThread() {
-        while (isRunning.get()) {
-			final int currentTurn = game.getCurrentTurn();
-			final String currentValue = currentTurn == 0? "RED" : "BLUE";
-			final int nextTurn = (currentTurn + 1) % information.type.getPlayerCount();
-
-			primary.nextPlayer(information.players[currentTurn].isHuman,
-				information.players[currentTurn].name,
-				currentValue,
-				information.players[nextTurn].name);
-
-            Move move = null;
-
-            if (information.players[currentTurn].isHuman) {
-                try {
-                    final Move wants = moveQueue.take();
-                    final Move[] legalMoves = game.getLegalMoves();
-
-                    for (final Move legalMove : legalMoves) {
-                        if (legalMove.position() == wants.position() &&
-                                legalMove.value() == wants.value()) {
-                            move = wants;
-                            break;
-                        }
-                    }
-                } catch (InterruptedException _) {}
-            } else {
-                final long start = System.currentTimeMillis();
-
-                move = ai.findBestMove(game, information.players[currentTurn].computerDifficulty);
-
-                if (information.players[currentTurn].computerThinkTime > 0) {
-                    final long elapsedTime = System.currentTimeMillis() - start;
-                    final long sleepTime = Math.abs(information.players[currentTurn].computerThinkTime * 1000L - elapsedTime);
-
-                    try {
-                        Thread.sleep((long)(sleepTime * Math.random()));
-                    } catch (InterruptedException _) {}
-                }
-            }
-
-            if (move == null) {
-                continue;
-            }
-
-            final GameState state = game.play(move);
-            updateCanvas();
-/*
-            if (move.value() == 'X') {
-                canvas.drawX(Color.INDIANRED, move.position());
-            } else if (move.value() == 'O') {
-                canvas.drawO(Color.ROYALBLUE, move.position());
-            }
-*/
-            if (state != GameState.NORMAL) {
-                if (state == GameState.WIN) {
-                    primary.gameOver(true, information.players[currentTurn].name);
-                } else if (state == GameState.DRAW) {
-                    primary.gameOver(false, "");
-                }
-
-                isRunning.set(false);
-            }
-        }
-    }
-
-    private void onMoveResponse(NetworkEvents.GameMoveResponse response) {
-        if (!isRunning.get()) {
-            return;
-        }
-
-        char playerChar;
-
-        if (response.player().equalsIgnoreCase(information.players[0].name)) {
-            playerChar = myTurn == 0? 'X' : 'O';
-        } else {
-            playerChar = myTurn == 0? 'O' : 'X';
-        }
-
-        final Move move = new Move(Integer.parseInt(response.move()), playerChar);
-        final GameState state = game.play(move);
-
-        if (state != GameState.NORMAL) {
-            if (state == GameState.WIN) {
-                if (response.player().equalsIgnoreCase(information.players[0].name)) {
-                    primary.gameOver(true, information.players[0].name);
-                    gameOver();
-                } else {
-                    primary.gameOver(false, information.players[1].name);
-                    gameOver();
-                }
-            } else if (state == GameState.DRAW) {
-                primary.gameOver(false, "");
-                gameOver();
-            }
-        }
-
-        if (move.value() == 'X') {
-            canvas.drawDot(Color.INDIANRED, move.position());
-        } else if (move.value() == 'O') {
-            canvas.drawDot(Color.ROYALBLUE, move.position());
-        }
-
-        updateCanvas();
-        setGameLabels(game.getCurrentTurn() == myTurn);
-    }
-
-    private void gameOver() {
-        if (onGameOver == null){
-            return;
-        }
-        isRunning.set(false);
-        onGameOver.run();
-    }
-
-    private void onYourTurnResponse(NetworkEvents.YourTurnResponse response) {
-
-        if (!isRunning.get()) {
-            return;
-        }
-
-        moveQueue.clear();
-
-        int position = -1;
-
-        if (information.players[0].isHuman) {
-            try {
-                position = moveQueue.take().position();
-            } catch (InterruptedException _) {}
-        } else {
-            final Move move = ai.findBestMove(game, information.players[0].computerDifficulty);
-
-            assert move != null;
-            position = move.position();
-        }
-
-        new EventFlow().addPostEvent(new NetworkEvents.SendMove(response.clientId(), (short)position))
-                .postEvent();
-    }
-
-    private void updateCanvas() {
-        canvas.clearAll();
-
-        for (int i = 0; i < game.getBoard().length; i++) {
-            if (game.getBoard()[i] == 'X') {
-                canvas.drawDot(Color.RED, i);
-            } else if (game.getBoard()[i] == 'O') {
-                canvas.drawDot(Color.BLUE, i);
-            }
-        }
-    }
-
-    private void setGameLabels(boolean isMe) {
-        final int currentTurn = game.getCurrentTurn();
-        final String currentValue = currentTurn == 0? "RED" : "BLUE";
-
-        primary.nextPlayer(isMe,
-                information.players[isMe? 0 : 1].name,
-                currentValue,
-                information.players[isMe? 1 : 0].name);
-    }
-}

app/src/main/java/org/toop/app/game/ReversiGame.java

@@ -1,333 +0,0 @@
-package org.toop.app.game;
-
-import javafx.animation.SequentialTransition;
-import org.toop.app.App;
-import org.toop.app.GameInformation;
-import org.toop.app.canvas.ReversiCanvas;
-import org.toop.app.widget.WidgetContainer;
-import org.toop.app.widget.view.GameView;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-import org.toop.game.reversi.Reversi;
-import org.toop.game.reversi.ReversiAI;
-
-import javafx.geometry.Pos;
-import javafx.scene.paint.Color;
-
-import java.awt.*;
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
-
-public final class ReversiGame {
-	private final GameInformation information;
-
-	private final int myTurn;
-    private final Runnable onGameOver;
-    private final BlockingQueue<Move> moveQueue;
-
-	private final Reversi game;
-	private final ReversiAI ai;
-
-	private final GameView primary;
-	private final ReversiCanvas canvas;
-
-	private final AtomicBoolean isRunning;
-	private final AtomicBoolean isPaused;
-
-	public ReversiGame(GameInformation information, int myTurn, Runnable onForfeit, Runnable onExit, Consumer<String> onMessage, Runnable onGameOver) {
-		this.information = information;
-
-		this.myTurn = myTurn;
-        this.onGameOver = onGameOver;
-        moveQueue = new LinkedBlockingQueue<>();
-
-		game = new Reversi();
-		ai = new ReversiAI();
-
-		isRunning = new AtomicBoolean(true);
-		isPaused = new AtomicBoolean(false);
-
-		if (onForfeit == null || onExit == null) {
-			primary = new GameView(null, () -> {
-				isRunning.set(false);
-				WidgetContainer.getCurrentView().transitionPrevious();
-			}, null, "Reversi");
-		} else {
-			primary = new GameView(onForfeit, () -> {
-				isRunning.set(false);
-				onExit.run();
-			}, onMessage, "Reversi");
-		}
-
-		canvas = new ReversiCanvas(Color.BLACK,
-			(App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,
-			(cell) -> {
-				if (onForfeit == null || onExit == null) {
-					if (information.players[game.getCurrentTurn()].isHuman) {
-						final char value = game.getCurrentTurn() == 0? 'B' : 'W';
-
-						try {
-							moveQueue.put(new Move(cell, value));
-						} catch (InterruptedException _) {}
-					}
-				} else {
-					if (information.players[0].isHuman) {
-						final char value = myTurn == 0? 'B' : 'W';
-
-						try {
-							moveQueue.put(new Move(cell, value));
-						} catch (InterruptedException _) {}
-					}
-				}
-			},this::highlightCells);
-
-
-
-		primary.add(Pos.CENTER, canvas.getCanvas());
-		WidgetContainer.getCurrentView().transitionNext(primary);
-
-		if (onForfeit == null || onExit == null) {
-			new Thread(this::localGameThread).start();
-			setGameLabels(information.players[0].isHuman);
-		} else {
-			new EventFlow()
-				.listen(NetworkEvents.GameMoveResponse.class, this::onMoveResponse)
-				.listen(NetworkEvents.YourTurnResponse.class, this::onYourTurnResponse);
-
-			setGameLabels(myTurn == 0);
-		}
-
-		updateCanvas(false);
-	}
-
-	public ReversiGame(GameInformation information) {
-		this(information, 0, null, null, null,null);
-	}
-
-	private void localGameThread() {
-		while (isRunning.get()) {
-			if (isPaused.get()) {
-				try {
-					Thread.sleep(200);
-				} catch (InterruptedException _) {}
-
-				continue;
-			}
-
-			final int currentTurn = game.getCurrentTurn();
-			final String currentValue = currentTurn == 0? "BLACK" : "WHITE";
-			final int nextTurn = (currentTurn + 1) % information.type.getPlayerCount();
-
-			primary.nextPlayer(information.players[currentTurn].isHuman,
-				information.players[currentTurn].name,
-				currentValue,
-				information.players[nextTurn].name);
-
-			Move move = null;
-
-			if (information.players[currentTurn].isHuman) {
-				try {
-					final Move wants = moveQueue.take();
-					final Move[] legalMoves = game.getLegalMoves();
-
-					for (final Move legalMove : legalMoves) {
-						if (legalMove.position() == wants.position() &&
-							legalMove.value() == wants.value()) {
-							move = wants;
-							break;
-						}
-					}
-				} catch (InterruptedException _) {}
-			} else {
-				final long start = System.currentTimeMillis();
-
-				move = ai.findBestMove(game, information.players[currentTurn].computerDifficulty);
-
-				if (information.players[currentTurn].computerThinkTime > 0) {
-					final long elapsedTime = System.currentTimeMillis() - start;
-					final long sleepTime = information.players[currentTurn].computerThinkTime * 1000L - elapsedTime;
-
-					try {
-						Thread.sleep((long) (sleepTime * Math.random()));
-					} catch (InterruptedException _) {}
-				}
-			}
-
-			if (move == null) {
-				continue;
-			}
-
-            canvas.setCurrentlyHighlightedMovesNull();
-			final GameState state = game.play(move);
-			updateCanvas(true);
-
-			if (state != GameState.NORMAL) {
-                if (state == GameState.TURN_SKIPPED){
-                    continue;
-                }
-                int winningPLayerNumber = getPlayerNumberWithHighestScore();
-				if (state == GameState.WIN && winningPLayerNumber > -1) {
-					primary.gameOver(true, information.players[winningPLayerNumber].name);
-				} else if (state == GameState.DRAW || winningPLayerNumber == -1) {
-					primary.gameOver(false, "");
-				}
-
-				isRunning.set(false);
-			}
-		}
-	}
-
-    private int getPlayerNumberWithHighestScore(){
-        Reversi.Score score = game.getScore();
-        if (score.player1Score() > score.player2Score()) return 0;
-        if (score.player1Score() < score.player2Score()) return 1;
-        return -1;
-    }
-
-	private void onMoveResponse(NetworkEvents.GameMoveResponse response) {
-		if (!isRunning.get()) {
-			return;
-		}
-
-		char playerChar;
-
-		if (response.player().equalsIgnoreCase(information.players[0].name)) {
-			playerChar = myTurn == 0? 'B' : 'W';
-		} else {
-			playerChar = myTurn == 0? 'W' : 'B';
-		}
-
-		final Move move = new Move(Integer.parseInt(response.move()), playerChar);
-		final GameState state = game.play(move);
-
-		if (state != GameState.NORMAL) {
-			if (state == GameState.WIN) {
-				if (response.player().equalsIgnoreCase(information.players[0].name)) {
-					primary.gameOver(true, information.players[0].name);
-                    gameOver();
-				} else {
-					primary.gameOver(false, information.players[1].name);
-                    gameOver();
-				}
-			} else if (state == GameState.DRAW) {
-				primary.gameOver(false, "");
-                game.play(move);
-			}
-		}
-
-		updateCanvas(false);
-		setGameLabels(game.getCurrentTurn() == myTurn);
-	}
-
-    private void gameOver() {
-        if (onGameOver == null){
-            return;
-        }
-        isRunning.set(false);
-        onGameOver.run();
-    }
-
-	private void onYourTurnResponse(NetworkEvents.YourTurnResponse response) {
-		if (!isRunning.get()) {
-			return;
-		}
-
-		moveQueue.clear();
-
-		int position = -1;
-
-		if (information.players[0].isHuman) {
-			try {
-				position = moveQueue.take().position();
-			} catch (InterruptedException _) {}
-		} else {
-			final Move move = ai.findBestMove(game, information.players[0].computerDifficulty);
-
-			assert move != null;
-			position = move.position();
-		}
-
-		new EventFlow().addPostEvent(new NetworkEvents.SendMove(response.clientId(), (short) position))
-			.postEvent();
-	}
-
-	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] == 'B') {
-				canvas.drawDot(Color.BLACK, i);
-			} else if (game.getBoard()[i] == 'W') {
-				canvas.drawDot(Color.WHITE, i);
-			}
-		}
-
-		final Move[] flipped = game.getMostRecentlyFlippedPieces();
-
-		final SequentialTransition animation = new SequentialTransition();
-		isPaused.set(true);
-
-		final Color fromColor = game.getCurrentPlayer() == 'W'? Color.WHITE : Color.BLACK;
-		final Color toColor = game.getCurrentPlayer() == 'W'? Color.BLACK : Color.WHITE;
-
-		if (animate && flipped != null) {
-			for (final Move flip : flipped) {
-				canvas.clear(flip.position());
-				canvas.drawDot(fromColor, flip.position());
-				animation.getChildren().addFirst(canvas.flipDot(fromColor, toColor, flip.position()));
-			}
-		}
-
-		animation.setOnFinished(_ -> {
-			isPaused.set(false);
-
-            if (information.players[game.getCurrentTurn()].isHuman) {
-                final Move[] legalMoves = game.getLegalMoves();
-
-                for (final Move legalMove : legalMoves) {
-                    canvas.drawLegalPosition(legalMove.position(), game.getCurrentPlayer());
-                }
-            }
-		});
-
-		animation.play();
-	}
-
-	private void setGameLabels(boolean isMe) {
-		final int currentTurn = game.getCurrentTurn();
-		final String currentValue = currentTurn == 0? "BLACK" : "WHITE";
-
-		primary.nextPlayer(isMe,
-			information.players[isMe? 0 : 1].name,
-			currentValue,
-			information.players[isMe? 1 : 0].name);
-	}
-
-    private void highlightCells(int cellEntered) {
-        if (information.players[game.getCurrentTurn()].isHuman) {
-            Move[] legalMoves = game.getLegalMoves();
-            boolean isLegalMove = false;
-            for (Move move : legalMoves) {
-                if (move.position() == cellEntered){
-                    isLegalMove = true;
-                    break;
-                }
-            }
-
-            if (cellEntered >= 0){
-                Move[] moves = null;
-                if (isLegalMove) {
-                    moves = game.getFlipsForPotentialMove(
-                            new Point(cellEntered%game.getColumnSize(),cellEntered/game.getRowSize()),
-                            game.getCurrentPlayer());
-                }
-                canvas.drawHighlightDots(moves);
-            }
-        }
-    }
-}

app/src/main/java/org/toop/app/game/TicTacToeGame.java

@@ -1,250 +0,0 @@
-package org.toop.app.game;
-
-import org.toop.app.App;
-import org.toop.app.GameInformation;
-import org.toop.app.canvas.TicTacToeCanvas;
-import org.toop.app.widget.WidgetContainer;
-import org.toop.app.widget.view.GameView;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-import org.toop.game.tictactoe.TicTacToe;
-import org.toop.game.tictactoe.TicTacToeAI;
-
-import javafx.geometry.Pos;
-import javafx.scene.paint.Color;
-
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.function.Consumer;
-
-public final class TicTacToeGame {
-	private final GameInformation information;
-
-	private final int myTurn;
-    private final Runnable onGameOver;
-    private final BlockingQueue<Move> moveQueue;
-
-	private final TicTacToe game;
-	private final TicTacToeAI ai;
-
-	private final GameView primary;
-	private final TicTacToeCanvas canvas;
-
-	private final AtomicBoolean isRunning;
-
-	public TicTacToeGame(GameInformation information, int myTurn, Runnable onForfeit, Runnable onExit, Consumer<String> onMessage, Runnable onGameOver) {
-		this.information = information;
-
-		this.myTurn = myTurn;
-        this.onGameOver = onGameOver;
-        moveQueue = new LinkedBlockingQueue<Move>();
-
-		game = new TicTacToe();
-		ai = new TicTacToeAI();
-
-		isRunning = new AtomicBoolean(true);
-
-		if (onForfeit == null || onExit == null) {
-			primary = new GameView(null, () -> {
-				isRunning.set(false);
-				WidgetContainer.getCurrentView().transitionPrevious();
-			}, null, "TicTacToe");
-		} else {
-			primary = new GameView(onForfeit, () -> {
-				isRunning.set(false);
-				onExit.run();
-			}, onMessage, "TicTacToe");
-		}
-
-		canvas = new TicTacToeCanvas(Color.GRAY,
-			(App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3,
-			(cell) -> {
-				if (onForfeit == null || onExit == null) {
-					if (information.players[game.getCurrentTurn()].isHuman) {
-						final char value = game.getCurrentTurn() == 0? 'X' : 'O';
-
-						try {
-							moveQueue.put(new Move(cell, value));
-						} catch (InterruptedException _) {}
-					}
-				} else {
-					if (information.players[0].isHuman) {
-						final char value = myTurn == 0? 'X' : 'O';
-
-						try {
-							moveQueue.put(new Move(cell, value));
-						} catch (InterruptedException _) {}
-					}
-				}
-			});
-
-		primary.add(Pos.CENTER, canvas.getCanvas());
-		WidgetContainer.getCurrentView().transitionNext(primary);
-
-		if (onForfeit == null || onExit == null) {
-			new Thread(this::localGameThread).start();
-		} else {
-			new EventFlow()
-				.listen(NetworkEvents.GameMoveResponse.class, this::onMoveResponse)
-				.listen(NetworkEvents.YourTurnResponse.class, this::onYourTurnResponse);
-
-			setGameLabels(myTurn == 0);
-		}
-	}
-
-	public TicTacToeGame(GameInformation information) {
-		this(information, 0, null, null, null, null);
-	}
-
-	private void localGameThread() {
-		while (isRunning.get()) {
-			final int currentTurn = game.getCurrentTurn();
-			final String currentValue = currentTurn == 0? "X" : "O";
-			final int nextTurn = (currentTurn + 1) % information.type.getPlayerCount();
-
-			primary.nextPlayer(information.players[currentTurn].isHuman,
-				information.players[currentTurn].name,
-				currentValue,
-				information.players[nextTurn].name);
-
-			Move move = null;
-
-			if (information.players[currentTurn].isHuman) {
-				try {
-					final Move wants = moveQueue.take();
-					final Move[] legalMoves = game.getLegalMoves();
-
-					for (final Move legalMove : legalMoves) {
-						if (legalMove.position() == wants.position() &&
-							legalMove.value() == wants.value()) {
-							move = wants;
-							break;
-						}
-					}
-				} catch (InterruptedException _) {}
-			} else {
-				final long start = System.currentTimeMillis();
-
-				move = ai.findBestMove(game, information.players[currentTurn].computerDifficulty);
-
-				if (information.players[currentTurn].computerThinkTime > 0) {
-					final long elapsedTime = System.currentTimeMillis() - start;
-					final long sleepTime = information.players[currentTurn].computerThinkTime * 1000L - elapsedTime;
-
-					try {
-						Thread.sleep((long)(sleepTime * Math.random()));
-					} catch (InterruptedException _) {}
-				}
-			}
-
-			if (move == null) {
-				continue;
-			}
-
-			final GameState state = game.play(move);
-
-			if (move.value() == 'X') {
-				canvas.drawX(Color.INDIANRED, move.position());
-			} else if (move.value() == 'O') {
-				canvas.drawO(Color.ROYALBLUE, move.position());
-			}
-
-			if (state != GameState.NORMAL) {
-				if (state == GameState.WIN) {
-					primary.gameOver(true, information.players[currentTurn].name);
-				} else if (state == GameState.DRAW) {
-					primary.gameOver(false, "");
-				}
-
-				isRunning.set(false);
-			}
-		}
-	}
-
- 	private void onMoveResponse(NetworkEvents.GameMoveResponse response) {
-		if (!isRunning.get()) {
-			return;
-		}
-
-	    char playerChar;
-
-	    if (response.player().equalsIgnoreCase(information.players[0].name)) {
-		    playerChar = myTurn == 0? 'X' : 'O';
-	    } else {
-		    playerChar = myTurn == 0? 'O' : 'X';
-	    }
-
-	    final Move move = new Move(Integer.parseInt(response.move()), playerChar);
-	    final GameState state = game.play(move);
-
-	    if (state != GameState.NORMAL) {
-		    if (state == GameState.WIN) {
-			    if (response.player().equalsIgnoreCase(information.players[0].name)) {
-					primary.gameOver(true, information.players[0].name);
-                    gameOver();
-			    } else {
-				    primary.gameOver(false, information.players[1].name);
-                    gameOver();
-			    }
-		    } else if (state == GameState.DRAW) {
-                if(game.getLegalMoves().length == 0) { //only return draw in online multiplayer if the game is actually over.
-                    primary.gameOver(false, "");
-                    gameOver();
-                }
-		    }
-	    }
-
-	    if (move.value() == 'X') {
-		    canvas.drawX(Color.RED, move.position());
-	    } else if (move.value() == 'O') {
-		    canvas.drawO(Color.BLUE, move.position());
-	    }
-
-		setGameLabels(game.getCurrentTurn() == myTurn);
-    }
-
-    private void gameOver() {
-        if (onGameOver == null){
-            return;
-        }
-        isRunning.set(false);
-        onGameOver.run();
-    }
-
- 	private void onYourTurnResponse(NetworkEvents.YourTurnResponse response) {
-	    if (!isRunning.get()) {
-		    return;
-	    }
-
-		moveQueue.clear();
-
- 		int position = -1;
-
- 		if (information.players[0].isHuman) {
- 			try {
- 				position = moveQueue.take().position();
- 			} catch (InterruptedException _) {}
- 		} else {
-             final Move move;
-             move = ai.findBestMove(game, information.players[0].computerDifficulty);
-			assert move != null;
- 			position = move.position();
- 		}
-
- 		new EventFlow().addPostEvent(new NetworkEvents.SendMove(response.clientId(), (short)position))
- 				.postEvent();
-    }
-
-	private void setGameLabels(boolean isMe) {
-		final int currentTurn = game.getCurrentTurn();
-		final String currentValue = currentTurn == 0? "X" : "O";
-
-		primary.nextPlayer(isMe,
-			information.players[isMe? 0 : 1].name,
-			currentValue,
-			information.players[isMe? 1 : 0].name);
-	}
-}

app/src/main/java/org/toop/app/game/TicTacToeGameThread.java

@@ -1,176 +0,0 @@
-package org.toop.app.game;
-
-import org.toop.app.App;
-import org.toop.app.GameInformation;
-import org.toop.app.canvas.TicTacToeCanvas;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.networking.events.NetworkEvents;
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-import org.toop.game.tictactoe.TicTacToe;
-import org.toop.game.tictactoe.TicTacToeAI;
-import java.util.function.Consumer;
-import javafx.geometry.Pos;
-import javafx.scene.paint.Color;
-
-public final class TicTacToeGameThread extends BaseGameThread<TicTacToe, TicTacToeAI, TicTacToeCanvas> {
-	public TicTacToeGameThread(GameInformation info, int myTurn, Runnable onForfeit, Runnable onExit, Consumer<String> onMessage, Runnable onGameOver) {
-		super(info, myTurn, onForfeit, onExit, onMessage, onGameOver,
-			TicTacToe::new,
-			TicTacToeAI::new,
-			clickHandler -> new TicTacToeCanvas(Color.GRAY, (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3, clickHandler)
-		);
-	}
-
-	public TicTacToeGameThread(GameInformation info) {
-        this(info, 0, null, null, null, null);
-    }
-
-	@Override
-	protected void addCanvasToPrimary() {
-		primary.add(Pos.CENTER, canvas.getCanvas());
-	}
-
-	@Override
-	protected int getCurrentTurn() {
-		return game.getCurrentTurn();
-	}
-
-	@Override
-	protected char getSymbolForTurn(int turn) {
-		return turn == 0 ? 'X' : 'O';
-	}
-
-	@Override
-	protected String getNameForTurn(int turn) {
-		return turn == 0 ? "X" : "O";
-	}
-
-	private void drawMove(Move move) {
-		if (move.value() == 'X') canvas.drawX(Color.RED, move.position());
-		else canvas.drawO(Color.BLUE, move.position());
-	}
-
-	@Override
-	protected void onMoveResponse(NetworkEvents.GameMoveResponse response) {
-		if (!isRunning.get()) {
-			return;
-		}
-
-		char playerChar;
-
-		if (response.player().equalsIgnoreCase(information.players[0].name)) {
-			playerChar = myTurn == 0? 'X' : 'O';
-		} else {
-			playerChar = myTurn == 0? 'O' : 'X';
-		}
-
-		final Move move = new Move(Integer.parseInt(response.move()), playerChar);
-		final GameState state = game.play(move);
-
-		if (state != GameState.NORMAL) {
-			if (state == GameState.WIN) {
-				if (response.player().equalsIgnoreCase(information.players[0].name)) {
-					primary.gameOver(true, information.players[0].name);
-					gameOver();
-				} else {
-					primary.gameOver(false, information.players[1].name);
-					gameOver();
-				}
-			} else if (state == GameState.DRAW) {
-				if (game.getLegalMoves().length == 0) {
-					primary.gameOver(false, "");
-					gameOver();
-				}
-			}
-		}
-
-		drawMove(move);
-		setGameLabels(game.getCurrentTurn() == myTurn);
-	}
-
-	@Override
-	protected void onYourTurnResponse(NetworkEvents.YourTurnResponse response) {
-		if (!isRunning.get()) {
-			return;
-		}
-
-		moveQueue.clear();
-
-		int position = -1;
-
-		if (information.players[0].isHuman) {
-			try {
-				position = moveQueue.take().position();
-			} catch (InterruptedException _) {}
-		} else {
-			final Move move;
-			if (information.players[1].name.equalsIgnoreCase("pism")) {
-				move = ai.findWorstMove(game,9);
-			}else{
-				move = ai.findBestMove(game, information.players[0].computerDifficulty);
-			}
-
-			assert move != null;
-			position = move.position();
-		}
-
-		new EventFlow().addPostEvent(new NetworkEvents.SendMove(response.clientId(), (short)position))
-			.postEvent();
-	}
-
-	@Override
-	protected void localGameThread() {
-		while (isRunning.get()) {
-			final int currentTurn = game.getCurrentTurn();
-			setGameLabels(currentTurn == myTurn);
-
-			Move move = null;
-
-			if (information.players[currentTurn].isHuman) {
-				try {
-					final Move wants = moveQueue.take();
-					final Move[] legalMoves = game.getLegalMoves();
-
-					for (final Move legalMove : legalMoves) {
-						if (legalMove.position() == wants.position() &&
-							legalMove.value() == wants.value()) {
-							move = wants;
-							break;
-						}
-					}
-				} catch (InterruptedException _) {}
-			} else {
-				final long start = System.currentTimeMillis();
-
-				move = ai.findBestMove(game, information.players[currentTurn].computerDifficulty);
-
-				if (information.players[currentTurn].computerThinkTime > 0) {
-					final long elapsedTime = System.currentTimeMillis() - start;
-					final long sleepTime = information.players[currentTurn].computerThinkTime * 1000L - elapsedTime;
-
-					try {
-						Thread.sleep((long)(sleepTime * Math.random()));
-					} catch (InterruptedException _) {}
-				}
-			}
-
-			if (move == null) {
-				continue;
-			}
-
-			final GameState state = game.play(move);
-			drawMove(move);
-
-			if (state != GameState.NORMAL) {
-				if (state == GameState.WIN) {
-					primary.gameOver(information.players[currentTurn].isHuman, information.players[currentTurn].name);
-				} else if (state == GameState.DRAW) {
-					primary.gameOver(false, "");
-				}
-
-				isRunning.set(false);
-			}
-		}
-	}
-}

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

@@ -1,10 +1,11 @@
 package org.toop.app.widget;
 
 import javafx.scene.image.ImageView;
+import org.toop.framework.audio.events.AudioEvents;
+import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.resource.resources.ImageAsset;
 import org.toop.local.AppContext;
 
-import java.awt.*;
 import java.io.File;
 import java.util.function.Consumer;
 
@@ -23,30 +24,38 @@ import javafx.scene.text.Text;
 import javafx.util.StringConverter;
 
 public final class Primitive {
-	public static Text header(String key) {
+	public static Text header(String key, boolean localize) {
 		var header = new Text();
 		header.getStyleClass().add("header");
 
 		if (!key.isEmpty()) {
-			header.setText(AppContext.getString(key));
-			header.textProperty().bind(AppContext.bindToKey(key));
+			if (localize) header.setText(AppContext.getString(key)); else header.setText(key);
+			header.textProperty().bind(AppContext.bindToKey(key, localize));
 		}
 
 		return header;
 	}
 
-	public static Text text(String key) {
+	public static Text header(String key) {
+		return header(key, true);
+	}
+
+	public static Text text(String key, boolean localize) {
 		var text = new Text();
 		text.getStyleClass().add("text");
 
 		if (!key.isEmpty()) {
-			text.setText(AppContext.getString(key));
-			text.textProperty().bind(AppContext.bindToKey(key));
+			if (localize) text.setText(AppContext.getString(key)); else text.setText(key);
+			text.textProperty().bind(AppContext.bindToKey(key, localize));
 		}
 
 		return text;
 	}
 
+	public static Text text(String key) {
+		return text(key, true);
+	}
+
     public static ImageView image(ImageAsset imageAsset) {
         ImageView imageView = new ImageView(imageAsset.getImage());
         imageView.getStyleClass().add("image");
@@ -56,30 +65,36 @@ public final class  Primitive {
         return imageView;
     }
 
-	public static Button button(String key, Runnable onAction) {
+	public static Button button(String key, Runnable onAction, boolean localize) {
 		var button = new Button();
 		button.getStyleClass().add("button");
 
 		if (!key.isEmpty()) {
-			button.setText(AppContext.getString(key));
-			button.textProperty().bind(AppContext.bindToKey(key));
+			if (localize) button.setText(AppContext.getString(key));  else button.setText(key);
+			button.textProperty().bind(AppContext.bindToKey(key, localize));
 		}
 
 		if (onAction != null) {
-			button.setOnAction(_ ->
-				onAction.run());
+			button.setOnAction(_ -> {
+                onAction.run();
+                playButtonSound();
+            });
 		}
 
 		return button;
 	}
 
-	public static TextField input(String promptKey, String text, Consumer<String> onValueChanged) {
+	public static Button button(String key, Runnable onAction) {
+		return button(key, onAction, true);
+	}
+
+	public static TextField input(String promptKey, String text, Consumer<String> onValueChanged, boolean localize) {
 		var input = new TextField();
 		input.getStyleClass().add("input");
 
 		if (!promptKey.isEmpty()) {
-			input.setPromptText(AppContext.getString(promptKey));
-			input.promptTextProperty().bind(AppContext.bindToKey(promptKey));
+			if (localize) input.setPromptText(AppContext.getString(promptKey)); else input.setPromptText(promptKey);
+			input.promptTextProperty().bind(AppContext.bindToKey(promptKey, localize));
 		}
 
 		input.setText(text);
@@ -92,6 +107,10 @@ public final class  Primitive {
 		return input;
 	}
 
+	public static TextField input(String promptKey, String text, Consumer<String> onValueChanged) {
+		return input(promptKey, text, onValueChanged, true);
+	}
+
 	public static Slider slider(int min, int max, int value, Consumer<Integer> onValueChanged) {
 		var slider = new Slider();
 		slider.getStyleClass().add("slider");
@@ -101,10 +120,15 @@ public final class  Primitive {
 		slider.setValue(value);
 
         if (onValueChanged != null) {
-			slider.valueProperty().addListener((_, _, newValue) ->
-				onValueChanged.accept(newValue.intValue()));
+            slider.valueProperty().addListener((_, _, newValue) -> {
+                onValueChanged.accept(newValue.intValue());
+            });
         }
 
+        slider.setOnMouseReleased(event -> {
+            playButtonSound();
+        });
+
         return slider;
 	}
 
@@ -122,8 +146,10 @@ public final class  Primitive {
 		}
 
 		if (onValueChanged != null) {
-			choice.valueProperty().addListener((_, _, newValue) ->
-				onValueChanged.accept(newValue));
+            choice.valueProperty().addListener((_, _, newValue) -> {
+                onValueChanged.accept(newValue);
+                playButtonSound();
+            });
         }
 
 		choice.setItems(FXCollections.observableArrayList(items));
@@ -176,4 +202,8 @@ public final class  Primitive {
 
 		return vbox;
 	}
+
+    private static void playButtonSound() {
+        new EventFlow().addPostEvent(new AudioEvents.ClickButton()).postEvent();
+    }
 }

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

@@ -0,0 +1,162 @@
+package org.toop.app.widget.complex;
+
+import javafx.application.Platform;
+import javafx.geometry.Pos;
+import javafx.scene.control.Control;
+import javafx.scene.control.ProgressBar;
+import javafx.scene.control.ProgressIndicator;
+import javafx.scene.layout.VBox;
+import javafx.scene.text.Text;
+import org.toop.app.widget.Primitive;
+
+import java.util.concurrent.Callable;
+import java.util.concurrent.atomic.AtomicBoolean;
+
+public class LoadingWidget extends ViewWidget implements Update { // TODO make of widget type
+    private final Text loadingText; // TODO Make changeable
+    private final ProgressIndicator progressBar;
+    private final AtomicBoolean successTriggered = new AtomicBoolean(false);
+    private final AtomicBoolean failureTriggered = new AtomicBoolean(false);
+
+    private Runnable success = () -> {};
+    private Runnable failure = () -> {};
+    private int maxAmount;
+    private int minAmount;
+    private int amount;
+    private Callable<Boolean> successTrigger = () -> (amount >= maxAmount);
+    private Callable<Boolean> failureTrigger = () -> (amount < minAmount);
+    private float percentage = 0.0f;
+
+    private boolean isInfinite = false;
+
+    /**
+     *
+     * Widget that shows a loading bar.
+     *
+     * @param loadingText Text above the loading bar.
+     * @param minAmount The minimum amount.
+     * @param startAmount The starting amount.
+     * @param maxAmount The max amount.
+     */
+    public LoadingWidget(Text loadingText, int minAmount, int startAmount, int maxAmount, boolean infinite, boolean circle) {
+        isInfinite = infinite;
+
+        this.maxAmount = maxAmount;
+        this.minAmount = minAmount;
+        amount = startAmount;
+
+        this.loadingText = loadingText;
+        progressBar = circle ? new ProgressIndicator() : new ProgressBar();
+
+        VBox box = Primitive.vbox(this.loadingText, progressBar);
+        progressBar.getStyleClass().add("loading-progress-bar");
+        add(Pos.CENTER, box);
+    }
+
+    public void setMaxAmount(int maxAmount) {
+        this.maxAmount = maxAmount;
+    }
+
+    public void setAmount(int amount) throws Exception {
+        this.amount = amount;
+        update();
+    }
+
+    public int getMaxAmount() {
+        return maxAmount;
+    }
+
+    public int getAmount() {
+        return amount;
+    }
+
+    public float getPercentage() {
+        return percentage;
+    }
+
+    public boolean isTriggered() {
+        return (failureTriggered.get() || successTriggered.get());
+    }
+
+    public ProgressIndicator getProgressBar() {
+        return progressBar;
+    }
+
+    /**
+     * What to do when success is triggered.
+     * @param onSuccess The lambda that gets run on success.
+     */
+    public void setOnSuccess(Runnable onSuccess) {
+        success = onSuccess;
+    }
+
+    /**
+     * What to do when failure is triggered.
+     * @param onFailure The lambda that gets run on failure.
+     */
+    public void setOnFailure(Runnable onFailure) {
+        failure = onFailure;
+    }
+
+    /**
+     * The trigger to activate onSuccess.
+     * @param trigger The lambda that triggers onSuccess.
+     */
+    public void setSuccessTrigger(Callable<Boolean> trigger) {
+        successTrigger = trigger;
+    }
+
+    /**
+     * The trigger to activate onFailure.
+     * @param trigger The lambda that triggers onFailure.
+     */
+    public void setFailureTrigger(Callable<Boolean> trigger) {
+        failureTrigger = trigger;
+    }
+
+    /**
+     * Forcefully trigger success.
+     */
+    public void triggerSuccess() {
+		if (successTriggered.compareAndSet(false, true)) {
+			Platform.runLater(() -> {
+				if (success != null) success.run();
+			});
+		}
+    }
+
+    /**
+     * Forcefully trigger failure.
+     */
+    public void triggerFailure() {
+		if (failureTriggered.compareAndSet(false, true)) {
+			Platform.runLater(() -> {
+				if (failure != null) failure.run();
+			});
+		}
+    }
+
+    @Override
+    public void update() throws Exception { // TODO Better exception
+        if (successTriggered.get() || failureTriggered.get()) { // If already triggered, throw exception.
+            throw new RuntimeException();
+        }
+
+        if (successTrigger.call()) {
+            triggerSuccess();
+            this.remove(this);
+            return;
+        } else if (failureTrigger.call()) {
+            triggerFailure();
+            this.remove(this);
+            return;
+        }
+
+        if (maxAmount != 0) {
+            percentage = (float) amount / maxAmount;
+        }
+        if (!isInfinite) {
+            progressBar.setProgress(percentage);
+        }
+    }
+}

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

@@ -2,6 +2,8 @@ package org.toop.app.widget.complex;
 
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.Widget;
+import org.toop.framework.audio.events.AudioEvents;
+import org.toop.framework.eventbus.EventFlow;
 import org.toop.local.AppContext;
 
 import java.util.function.Consumer;
@@ -30,6 +32,7 @@ public class ToggleWidget implements Widget {
 			updateText();
 			if (onToggle != null) {
                 onToggle.accept(state);
+                new EventFlow().addPostEvent(new AudioEvents.ClickButton()).postEvent(); // TODO FIX PRIMITIVES
             }
 		});
 

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

@@ -0,0 +1,5 @@
+package org.toop.app.widget.complex;
+
+public interface Update {
+    void update() throws Exception;
+}

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

@@ -17,7 +17,17 @@ public abstract class ViewWidget extends StackWidget {
 	}
 
     public void transitionNext(ViewWidget view) {
+        transitionNext(view, false);
+    }
+
+	public void transitionNext(ViewWidget view, boolean aware) {
+        if (aware && this.getClass().equals(view.getClass())) {
+            view.previous = this.previous;
+        }
+        else{
             view.previous = this;
+        }
+
 		replace(Pos.CENTER, view);
 
 		var backButton = Primitive.button("back", () -> {

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

@@ -1,8 +1,5 @@
 package org.toop.app.widget.display;
 
-import javafx.animation.KeyFrame;
-import javafx.animation.Timeline;
-import javafx.util.Duration;
 import org.toop.app.widget.Widget;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
@@ -18,17 +15,14 @@ import javafx.scene.layout.Region;
 import javafx.scene.layout.VBox;
 import javafx.scene.text.Text;
 
-import java.util.Timer;
-
 public class SongDisplay extends VBox implements Widget {
 	private final Text songTitle;
 	private final ProgressBar progressBar;
 	private final Text progressText;
-    private boolean canClick = true;
 
 	public SongDisplay() {
 		new EventFlow()
-			.listen(this::updateTheSong);
+				.listen(AudioEvents.PlayingMusic.class, this::updateTheSong, false);
 
 		setAlignment(Pos.CENTER);
 		setMaxHeight(Region.USE_PREF_SIZE);
@@ -39,7 +33,7 @@ public class SongDisplay extends VBox implements Widget {
 		songTitle.getStyleClass().add("song-title");
 
 		progressBar = new ProgressBar(0);
-		progressBar.getStyleClass().add("progress-bar");
+		progressBar.getStyleClass().add("loading-progress-bar");
 
 		progressText = new Text("0:00/0:00");
 		progressText.getStyleClass().add("progress-text");
@@ -55,13 +49,10 @@ public class SongDisplay extends VBox implements Widget {
 		previousButton.getStyleClass().setAll("previous-button");
 
 		skipButton.setOnAction( event -> {
-            if (!canClick) { return; }
 			GlobalEventBus.post(new AudioEvents.SkipMusic());
-            doCooldown();
 		});
 
 		pauseButton.setOnAction(event -> {
-            if (!canClick) { return; }
 			GlobalEventBus.post(new AudioEvents.PauseMusic());
 			if (pauseButton.getText().equals("⏸")) {
 				pauseButton.setText("▶");
@@ -69,13 +60,10 @@ public class SongDisplay extends VBox implements Widget {
 			else if (pauseButton.getText().equals("▶")) {
 				pauseButton.setText("⏸");
 			}
-            doCooldown();
 		});
 
 		previousButton.setOnAction( event -> {
-            if (!canClick) { return; }
 			GlobalEventBus.post(new AudioEvents.PreviousMusic());
-            doCooldown();
 		});
 
 		HBox control = new HBox(10, previousButton, pauseButton, skipButton);
@@ -122,16 +110,6 @@ public class SongDisplay extends VBox implements Widget {
 		return time;
 	}
 
-    private void doCooldown() {
-        canClick = false;
-        Timeline cooldown = new Timeline(
-                new KeyFrame(Duration.millis(300), event -> canClick = true)
-        );
-        cooldown.setCycleCount(1);
-        cooldown.play();
-    }
-
-
 	@Override
 	public Node getNode() {
 		return this;

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

@@ -7,18 +7,17 @@ import org.toop.local.AppContext;
 import javafx.geometry.Pos;
 
 public final class GameOverPopup extends PopupWidget {
-	public GameOverPopup(boolean iWon, String winner) {
+	public GameOverPopup(boolean winOrTie, String winner) {
 		var confirmWidget = new ConfirmWidget("game-over");
 
-		if (winner.isEmpty()) {
-			confirmWidget.setMessage(AppContext.getString("the-game-ended-in-a-draw"));
-		} else if (iWon) {
-			confirmWidget.setMessage(AppContext.getString("you-win"));
-		} else {
-			confirmWidget.setMessage(AppContext.getString("you-lost-against") + ": " + winner);
+        if (winOrTie) {
+            confirmWidget.setMessage(winner + " won the game!");
+        }
+        else{
+            confirmWidget.setMessage("It was a tie!");
         }
 
-		confirmWidget.addButton("ok", () -> hide());
+		confirmWidget.addButton("ok", this::hide);
 
 		add(Pos.CENTER, confirmWidget);
 	}

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

@@ -87,7 +87,6 @@ public class BaseTutorialWidget extends PopupWidget implements Updatable {
                 this.hide();
                 nextScreen.run();
             });
-
         } else {
             nextButton.textProperty().unbind();
             nextButton.setText(AppContext.getString(">"));

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

@@ -2,14 +2,18 @@ package org.toop.app.widget.view;
 
 import javafx.application.Platform;
 import org.toop.app.GameInformation;
-import org.toop.app.game.Connect4Game;
-import org.toop.app.game.ReversiGame;
-import org.toop.app.game.TicTacToeGameThread;
+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.players.ArtificialPlayer;
+import org.toop.game.players.LocalPlayer;
 import org.toop.app.widget.Primitive;
-import org.toop.app.widget.WidgetContainer;
 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.local.AppContext;
 
@@ -17,9 +21,12 @@ import javafx.geometry.Pos;
 import javafx.scene.control.ScrollPane;
 import javafx.scene.layout.VBox;
 import org.toop.local.AppSettings;
+
 public class LocalMultiplayerView extends ViewWidget {
 	private final GameInformation information;
 
+    private AbstractGameController<?> gameController;
+
 	public LocalMultiplayerView(GameInformation.Type type) {
 		this(new GameInformation(type));
 	}
@@ -27,6 +34,9 @@ public class LocalMultiplayerView extends ViewWidget {
 	public LocalMultiplayerView(GameInformation information) {
 		this.information = information;
 		var playButton = Primitive.button("play", () -> {
+            if (gameController != null) {
+                gameController.stop();
+            }
 			for (var player : information.players) {
 				if (player.isHuman && player.name.isEmpty()) {
 					new ErrorPopup(AppContext.getString("please-enter-your-name")).show(Pos.CENTER);
@@ -34,42 +44,67 @@ public class LocalMultiplayerView extends ViewWidget {
 				}
 			}
 
+            // TODO: Fix this temporary ass way of setting the players (Only works for TicTacToe)
+            Player[] players = new Player[2];
+
 			switch (information.type) {
                 case TICTACTOE:
+                    if (information.players[0].isHuman) {
+                        players[0] = new LocalPlayer<>(information.players[0].name);
+                    } else {
+                        players[0] = new ArtificialPlayer<>(new TicTacToeAIR(), information.players[0].name);
+                    }
+                    if (information.players[1].isHuman) {
+                        players[1] = new LocalPlayer<>(information.players[1].name);
+                    } else {
+                        players[1] = new ArtificialPlayer<>(new TicTacToeAIR(), information.players[1].name);
+                    }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
                         new ShowEnableTutorialWidget(
-                                () -> new TicTacToeTutorialWidget(() -> new TicTacToeGameThread(information)),
-                                () -> Platform.runLater(() -> new TicTacToeGameThread(information)),
+                                () -> new TicTacToeTutorialWidget(() -> {
+                                    gameController = new TicTacToeController(players);
+                                    gameController.start();
+                                }),
+                                () -> Platform.runLater(() -> {
+                                    gameController = new TicTacToeController(players);
+                                    gameController.start();
+                                }),
                                 () -> AppSettings.getSettings().setFirstTTT(false)
                         );
                     } else {
-                        new TicTacToeGameThread(information);
+                        gameController = new TicTacToeController(players);
+                        gameController.start();
                     }
                     break;
                 case REVERSI:
+                    if (information.players[0].isHuman) {
+                        players[0] = new LocalPlayer<>(information.players[0].name);
+                    } else {
+                        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 ReversiAIR(), information.players[1].name);
+                    }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
                         new ShowEnableTutorialWidget(
-                                () -> new ReversiTutorialWidget(() -> new ReversiGame(information)),
-                                () -> Platform.runLater(() -> new ReversiGame(information)),
+                                () -> new ReversiTutorialWidget(() -> {
+                                    gameController = new ReversiController(players);
+                                    gameController.start();
+                                }),
+                                () -> Platform.runLater(() -> {
+                                    gameController = new ReversiController(players);
+                                    gameController.start();
+                                }),
                                 () -> AppSettings.getSettings().setFirstReversi(false)
                         );
                     } else {
-                        new ReversiGame(information);
-                    }
-                    break;
-                case CONNECT4:
-                    if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstConnect4()) {
-                        new ShowEnableTutorialWidget(
-                                () -> new Connect4TutorialWidget(() -> new Connect4Game(information)),
-                                () -> Platform.runLater(() -> new Connect4Game(information)),
-                                () -> AppSettings.getSettings().setFirstConnect4(false)
-                        );
-                    } else {
-                        new Connect4Game(information);
+                        gameController = new ReversiController(players);
+                        gameController.start();
                     }
                     break;
             }
-				// case BATTLESHIP -> new BattleshipGame(information);
         });
 
 		var playerSection = setupPlayerSections();

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

@@ -16,14 +16,9 @@ public class LocalView extends ViewWidget {
 			transitionNext(new LocalMultiplayerView(GameInformation.Type.REVERSI));
 		});
 
-		var connect4Button = Primitive.button("connect4", () -> {
-			transitionNext(new LocalMultiplayerView(GameInformation.Type.CONNECT4));
-		});
-
 		add(Pos.CENTER, Primitive.vbox(
 			ticTacToeButton,
-			reversiButton,
-			connect4Button
+			reversiButton
 		));
 	}
 }

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

@@ -29,7 +29,7 @@ public final class ServerView extends ViewWidget {
 	}
 
 	private void setupLayout() {
-		var playerHeader = Primitive.header(user);
+		var playerHeader = Primitive.header(user, false);
 
 		var playerListSection = Primitive.vbox(
 			playerHeader,
@@ -52,7 +52,7 @@ public final class ServerView extends ViewWidget {
 			listView.getItems().clear();
 
 			for (String player : players) {
-				var playerButton = Primitive.button(player, () -> onPlayerClicked.accept(player));
+				var playerButton = Primitive.button(player, () -> onPlayerClicked.accept(player), false);
 				listView.getItems().add(playerButton);
 			}
 		});

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

@@ -58,10 +58,19 @@ public class AppContext {
         return "MISSING RESOURCE";
     }
 
-	public static StringBinding bindToKey(String key) {
-		return Bindings.createStringBinding(
+	public static StringBinding bindToKey(String key, boolean localize) {
+        if (localize) return Bindings.createStringBinding(
                 () -> localization.getString(key, locale),
                 localeProperty
         );
+
+        return Bindings.createStringBinding(
+                () -> key
+        );
+
+	}
+
+    public static StringBinding bindToKey(String key) {
+        return bindToKey(key, true);
     }
 }

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

@@ -27,6 +27,13 @@ public class AppSettings {
 
 		AppContext.setLocale(Locale.of(settingsData.locale));
 		App.setFullscreen(settingsData.fullScreen);
+
+		App.setStyle(settingsAsset.getTheme(), settingsAsset.getLayoutSize());
+	}
+
+	public static void applyMusicVolumeSettings() {
+		Settings settingsData = settingsAsset.getContent();
+
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.volume, VolumeControl.MASTERVOLUME))
 				.asyncPostEvent();
@@ -36,7 +43,6 @@ public class AppSettings {
 		new EventFlow()
 				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.musicVolume, VolumeControl.MUSIC))
 				.asyncPostEvent();
-		App.setStyle(settingsAsset.getTheme(), settingsAsset.getLayoutSize());
 	}
 
 	public static SettingsAsset getPath() {

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

@@ -83,6 +83,8 @@ reversi2=\u0639\u0646\u062f\u0645\u0627 \u062a\u0646\u0642\u0631 \u0639\u0644\u0
 reversi3=\u0645\u0631\u062a\u0643 \u0642\u062f \u064a\u062a\u063a\u0627\u0637 \u0625\u0630\u0627 \u0644\u0645 \u064a\u0643\u0646 \u0647\u0646\u0627\u0643 \u062d\u0631\u0643 \u0642\u0627\u0646\u0648\u0646\u064a.  
 reversi4=\u0627\u0644\u0644\u0627\u0639\u0628 \u0627\u0644\u0630\u064a \u064a\u0641\u0648\u0632 \u0641\u064a \u0646\u0647\u0627\u064a\u0629 \u0627\u0644\u0644\u0639\u0628 \u0647\u0648 \u0627\u0644\u0630\u064a \u064a\u0643\u0648\u0646 \u0644\u062f\u064a\u0647 \u0627\u0644\u0623\u0643\u062b\u0631 \u0645\u0646 \u0627\u0644\u0644\u0648\u0639\u0627\u0628 \u0639\u0644\u0649 \u0627\u0644\u0644\u0648\u062d\u0629.  
 tutorialstring=\u0627\u0644\u062f\u0631\u0633 \u0627\u0644\u062a\u0648\u0636\u064a\u062d\u064a
+startgame=\u0627\u0628\u062f\u0623 \u0627\u0644\u0644\u0639\u0628\u0629!
+goback=\u0627\u0631\u062c\u0639
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629
 chinese=\u4e2d\u6587 (\u0627\u0644\u0635\u064a\u0646\u064a\u0629)

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

@@ -85,6 +85,8 @@ reversi2=Wenn du auf einen Punkt klickst, werden alle Spielsteine dazwischen umg
 reversi3=Dein Zug kann übersprungen werden, wenn es keinen legalen Zug gibt. Dein Gegner spielt dann weiter, bis du einen legalen Zug machen kannst.  
 reversi4=Der Spieler, der am Ende die meisten Steine auf dem Brett hat, gewinnt.  
 tutorialstring=Tutorial
+startgame=Spiel starten!
+goback=Zurück
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinesisch)

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

@@ -9,6 +9,8 @@ computer-difficulty=Computer difficulty
 computer-think-time=Computer think time
 computer=Computer
 connect=Connect
+connecting=Connecting to server...
+connecting-failed=Could not connect to server:
 credits=Credits
 dark=Dark
 deny=Deny

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

@@ -84,6 +84,8 @@ reversi2=Al hacer clic en un punto, se voltear
 reversi3=Tu turno puede ser saltado si no hay un movimiento legal. Esto permitirá que tu oponente juegue nuevamente hasta que tengas una oportunidad legal.  
 reversi4=El jugador que gane al final del juego es quien tenga más fichas en el tablero.  
 tutorialstring=Tutorial
+startgame=\u00a1Iniciar juego!
+goback=Volver
 
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Ar\u00e1bigo)

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

@@ -84,6 +84,8 @@ reversi2=Cliquer sur un point retournera tous les pions entre le point plac
 reversi3=Votre tour peut être sauté s'il n'y a pas de coup légal. Cela permettra à votre adversaire de jouer jusqu'à ce que vous ayez un coup légal.  
 reversi4=Le joueur qui a le plus de pions à la fin du jeu gagne.  
 tutorialstring=Tutoriel
+startgame=D\u00e9marrer le jeu!
+goback=Retour
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabe)
 chinese=\u4e2d\u6587 (Chinois)

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

@@ -84,6 +84,8 @@ reversi2=\u0915\u093f\u0938 \u092a\u0930 \u092a\u093f\u0938 \u092a\u0948\u0918 \
 reversi3=\u092f\u0939 \u092a\u0930\u094d\u092f \u0938\u0947 \u0938\u0947\u091a \u0915\u0940 \u091c\u093e\u0902\u091c \u0928\u0939\u0940\u0902 \u0939\u0948 \u0914\u0938\u0924\u0947 \u0915\u0948 \u092a\u0948\u0928 \u092a\u0930\u094d\u092f \u0939\u0948 \u0914\u092a\u0915\u0940 \u0915\u0940 \u092a\u0932\u0947 \u092d\u0942\u0924 \u0915\u0940 \u0906\u0927\u093e \u092a\u0948\u0928 \u091c\u093e\u0902\u091c \u0915\u0930 \u0938\u0915\u0924\u0947 \u0939\u0948\u0902.  
 reversi4=\u0916\u0941\u092f \u0915\u093f \u0915\u0940 \u0928\u093f\u092e\u0940 \u092e\u0947\u0902 \u091a\u093e\u0932 \u0938\u092c\u0938\u0947 \u091a\u0942\u0928\u094d\u0928\u0947 \u0939\u0948, \u0935\u0949 \u0915\u0947 \u092e\u093e\u0924\u094d\u0930 \u091c\u0940\u0924\u0947 \u0939\u0948.  
 tutorialstring=\u0924\u0942\u091f\u0949\u0930\u093f\u092f\u0932
+startgame=\u0916\u0947\u0932 \u0936\u0941\u0930\u0942 \u0915\u0930\u0947\u0902!
+goback=\u0935\u093e\u092a\u0938 \u091c\u093e\u090f\u0901
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0905\u0930\u092c\u0940)
 chinese=\u4e2d\u6587 (\u091a\u0940\u0928\u0940)

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

@@ -83,6 +83,8 @@ reversi2=Cliccando su un punto, tutti i pezzi tra dove metti il punto e il pross
 reversi3=Il tuo turno può essere saltato se non ci sono mosse legali. Questo permetterà al tuo avversario di giocare fino a quando non avrai un'opportunità legale.  
 reversi4=Il giocatore che alla fine del gioco ha più pezzi sulla scacchiera vince.  
 tutorialstring=Tutorial
+startgame=Avvia il gioco!
+goback=Indietro
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabo)
 chinese=\u4e2d\u6587 (Cinese)

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

@@ -83,6 +83,8 @@ reversi2=\u30af\u30ea\u30c3\u30af\u3059\u308b\u3068\u3001\u3064\u306a\u304c\u308
 reversi3=\u6b21\u306e\u52d5\u304b\u3057\u304c\u306a\u3044\u5834\u5408\u3001\u8a8d\u5b9a\u3055\u308c\u305f\u52d5\u304b\u3057\u306e\u6642\u9593\u306f\u62d2\u7d76\u3055\u308c\u308b\u3053\u3068\u304c\u3042\u308a\u307e\u3059\u3002  
 reversi4=\u672c\u6b21\u306b\u30dc\u30fc\u30c9\u4e0a\u3067\u6700\u591a\u306e\u8ca0\u3051\u3092\u6301\u3064\u30d7\u30ec\u30a4\u30e4\u30fc\u304c\u52dd\u3061\u307e\u3059\u3002  
 tutorialstring=\u30c1\u30e5\u30fc\u30c8\u30ea\u30a2\u30eb
+startgame=\u30b2\u30fc\u30e0\u3092\u958b\u59cb\uff01
+goback=\u623b\u308b
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u30a2\u30e9\u30d3\u30a2\u8a9e)
 chinese=\u4e2d\u6587 (\u4e2d\u6587)

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

@@ -83,6 +83,8 @@ reversi2=\ud074\ub9ad \ud558\uba70, \ub2e4\ub978 \ud648 \uc704\ub85c \ucd5c\uc2e
 reversi3=\uc0ac\uc6a9\uc790\uc758 \ud648\uc744 \ud074 \uc218 \uc5c6\uc2b5\uc2b5\ub2c8\ub2e4. \uc0ac\uc6a9\uc790 \ub2f5\uc5d0 \ub300\ud574 \uc811\ub2c8\ub2e4.  
 reversi4=\uacbd\uc6b0 \uc5d0\uc11c \ucd5c\ub300 \ud648\uc744 \uac00\uc838\ub294 \uc0ac\uc6a9\uc790\uc774 \uc52c\uc544\uc624\uba70 \uc0ac\uc6a9\uc790\uc758 \ud648\uc744 \uc54c\ub824\ud569\ub2c8\ub2e4.  
 tutorialstring=\ud14c\ud2b8\ub9ad
+startgame=\uac8c\uc784 \uc2dc\uc791!
+goback=\ub4a4\ub85c \uac00\uae30
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0639\u0631\u0628\u064a\u0629)
 chinese=\u4e2d\u6587 (\u4e2d\u6587)

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

@@ -83,6 +83,8 @@ reversi2=Door op een stip te klikken draai je alle stukken om tussen de plaats w
 reversi3=Je beurt kan worden overgeslagen als er geen legale zet is. Hierdoor kan je tegenstander doorgaan tot jij een legale zet kunt doen.  
 reversi4=De speler die aan het einde van het spel de meeste stukken op het bord heeft, wint.  
 tutorialstring=Tutorial
+startgame=Spel starten!
+goback=Ga terug
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinees)

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

@@ -83,6 +83,8 @@ reversi2=\u041d043 \u043d043 \u0430043 \u043a043 \u0430043 \u043a043 \u043e043 \
 reversi3=\u0412043 \u0430043 \u0436043 \u0434043 \u0430043 \u043d043 \u0438043 \u043d043 \u0435043 \u0435043 \u0432043 \u0430043.  
 reversi4=\u0418043 \u0433043 \u0440043 \u043e043 \u043a043 \u043e043 \u0442043 \u043e043 \u0442043 \u043e043 \u0435043 \u0435043 \u0430043 \u0435043 \u043d043 \u0438043 \u0435043 \u0435043 \u043c043 \u0430043.  
 tutorialstring=\u0423\u0447\u0435\u0431\u043d\u0438\u043a
+startgame=\u041d\u0430\u0447\u0430\u0442\u044c \u0438\u0433\u0440\u0443!
+goback=\u041d\u0430\u0437\u0430\u0434
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u0410\u0440\u0430\u0431\u0441\u043a\u0438\u0439)
 chinese=\u4e2d\u6587 (\u041a\u0438\u0442\u0430\u0439\u0441\u043a\u0438\u0439)

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

@@ -83,6 +83,8 @@ reversi2=\u70b9\u51fb\u4e00\u4e2a\u70b9\u65f6\u5c06\u5c06\u6240\u6709\u4e2d\u95f
 reversi3=\u5982\u679c\u6ca1\u6709\u5408\u6cd5\u64cd\u4f5c\u4f60\u7684\u8fdb\u6b65\u53ef\u80fd\u88ab\u5ffd\u7565. \u8fd9\u4f1a\u8ba9\u5bf9\u624b\u518d\u6b21\u64cd\u4f5c\u5230\u4f60\u6709\u5408\u6cd5\u64cd\u4f5c\u65f6.  
 reversi4=\u672c\u6e38\u620f\u7ed3\u675f\u65f6\u8d62\u5f97\u6ee1\u8fc7\u76d8\u9762\u7684\u4ee3\u7406\u6570\u6700\u591a\u7684\u4eba\u5c31\u80dc.  
 tutorialstring=\u6559\u7a0b
+startgame=\u5f00\u59cb\u6e38\u620f\uff01
+goback=\u8fd4\u56de
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (\u963f\u62c9\u4f2f\u8bed)
 chinese=\u4e2d\u6587

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

@@ -16,7 +16,6 @@
     -fx-padding: 8 12 8 12;
     -fx-spacing: 6px;
     -fx-alignment: center;
-    -fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.5), 6, 0.5, 0, 2);
     -fx-min-width: 220px;
     -fx-max-width: 260px;
 }
@@ -39,6 +38,18 @@
     -fx-background-radius: 30px;
 }
 
+.loading-progress-bar {
+	-fx-progress-color: #3caf3f;
+}
+
+.loading-progress-bar > .bar {
+	-fx-background-color: #3caf3f;
+}
+
+.loading-progress-bar > .track {
+	-fx-background-color: rgba(0,0,0,0.15);
+}
+
 .progress-text {
     -fx-font-size: 11px;
     -fx-fill: white;

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

@@ -16,7 +16,6 @@
 	-fx-padding: 8 12 8 12;
 	-fx-spacing: 6px;
 	-fx-alignment: center;
-    -fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.5), 6, 0.5, 0, 2);
 	-fx-min-width: 220px;
 	-fx-max-width: 260px;
 }
@@ -27,6 +26,7 @@
 }
 
 .progress-bar {
+	-fx-inner-background-color: black;
 	-fx-pref-width: 200px;
 	-fx-accent: red;
 }
@@ -39,6 +39,18 @@
 	-fx-background-radius: 30px;
 }
 
+.loading-progress-bar {
+	-fx-progress-color: #28a428;
+}
+
+.loading-progress-bar > .bar {
+	-fx-background-color: #28a428;
+}
+
+.loading-progress-bar > .track {
+	-fx-background-color: rgba(0,0,0,0.15);
+}
+
 .progress-text {
 	-fx-font-size: 11px;
 	-fx-fill: white;
@@ -48,10 +60,9 @@
 	-fx-background-color: transparent;
 	-fx-background-radius: 0;
 	-fx-cursor: hand;
- 	-fx-text-fill: white;
 }
 
-.skip-button .text {
+.skip-button > .text {
 	-fx-fill: white;
 }
 
@@ -59,10 +70,9 @@
 	-fx-background-color: transparent;
 	-fx-background-radius: 0;
 	-fx-cursor: hand;
- 	-fx-text-fill: white;
 }
 
-.pause-button .text {
+.pause-button > .text {
 	-fx-fill: white;
 }
 
@@ -70,10 +80,9 @@
 	-fx-background-color: transparent;
 	-fx-background-radius: 0;
 	-fx-cursor: hand;
- 	-fx-text-fill: white;
 }
 
-.previous-button .text {
+.previous-button > .text {
 	-fx-fill: white;
 }
 

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

@@ -16,14 +16,13 @@
 	-fx-padding: 8 12 8 12;
 	-fx-spacing: 6px;
 	-fx-alignment: center;
-    -fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.5), 6, 0.5, 0, 2);
 	-fx-min-width: 220px;
 	-fx-max-width: 260px;
 }
 
 .song-title {
 	-fx-font-size: 14px;
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .progress-bar {
@@ -40,42 +39,53 @@
 	-fx-background-radius: 30px;
 }
 
+.loading-progress-bar {
+	-fx-progress-color: #3caf3f;
+}
+
+.loading-progress-bar > .bar {
+	-fx-background-color: linear-gradient(to bottom, #a2d1a1, #b8e3b9);
+}
+
+.loading-progress-bar > .track {
+	-fx-background-color: rgba(0,0,0,0.15);
+}
+
 .progress-text {
 	-fx-font-size: 11px;
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .skip-button {
 	-fx-background-color: transparent;
 	-fx-background-radius: 0;
 	-fx-cursor: hand;
- 	-fx-text-fill: black;
+	-fx-effect: null;
 }
 
 .skip-button .text {
-    -fx-fill: black;
 }
 
 .pause-button {
 	-fx-background-color: transparent;
 	-fx-background-radius: 0;
 	-fx-cursor: hand;
- 	-fx-text-fill: black;
+	-fx-effect: null;
 }
 
 .pause-button .text {
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .previous-button {
 	-fx-background-color: transparent;
 	-fx-background-radius: 0;
 	-fx-cursor: hand;
- 	-fx-text-fill: black;
+	-fx-effect: null;
 }
 
 .previous-button .text {
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .button {

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

@@ -25,17 +25,16 @@ public class AudioEventListener<T extends AudioResource, K extends AudioResource
 
     public AudioEventListener<?, ?> initListeners(String buttonSoundToPlay) {
         new EventFlow()
-                .listen(this::handleStopMusicManager)
-                .listen(this::handlePlaySound)
-                .listen(this::handleSkipSong)
-                .listen(this::handlePauseSong)
-                .listen(this::handlePreviousSong)
-                .listen(this::handleStopSound)
-                .listen(this::handleMusicStart)
-                .listen(this::handleVolumeChange)
-                .listen(this::handleGetVolume)
-                .listen(AudioEvents.ClickButton.class, _ ->
-                        soundEffectManager.play(buttonSoundToPlay, false));
+                .listen(AudioEvents.StopAudioManager.class, this::handleStopMusicManager, false)
+                .listen(AudioEvents.PlayEffect.class, this::handlePlaySound, false)
+                .listen(AudioEvents.SkipMusic.class, this::handleSkipSong, false)
+                .listen(AudioEvents.PauseMusic.class, this::handlePauseSong, false)
+                .listen(AudioEvents.PreviousMusic.class, this::handlePreviousSong, false)
+                .listen(AudioEvents.StopEffect.class, this::handleStopSound, false)
+                .listen(AudioEvents.StartBackgroundMusic.class, this::handleMusicStart, false)
+                .listen(AudioEvents.ChangeVolume.class, this::handleVolumeChange, false)
+                .listen(AudioEvents.GetVolume.class, this::handleGetVolume,false)
+                .listen(AudioEvents.ClickButton.class, _ -> soundEffectManager.play(buttonSoundToPlay, false), false);
 
         return this;
     }

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

@@ -38,7 +38,7 @@ public class EventFlow {
     private EventType event = null;
 
     /** The listener returned by GlobalEventBus subscription. Used for unsubscription. */
-    private final List<ListenerHandler> listeners = new ArrayList<>();
+    private final List<ListenerHandler<?>> listeners = new ArrayList<>();
 
     /** Holds the results returned from the subscribed event, if any. */
     private Map<String, ?> result = null;
@@ -46,16 +46,15 @@ public class EventFlow {
     /** Empty constructor (event must be added via {@link #addPostEvent(Class, Object...)}). */
     public EventFlow() {}
 
-    public EventFlow addPostEvent(EventType event) {
-        this.event = event;
-        return this;
-    }
-
-    public EventFlow addPostEvent(Supplier<? extends EventType> eventSupplier) {
-        this.event = eventSupplier.get();
-        return this;
-    }
-
+    /**
+     *
+     * Add an event that will be triggered when {@link #postEvent()} or {@link #asyncPostEvent()} is called.
+     *
+     * @param eventClass The event that will be posted.
+     * @param args The event arguments, see the added event record for more information.
+     * @return {@link #EventFlow}
+     *
+     */
     public <T extends EventType> EventFlow addPostEvent(Class<T> eventClass, Object... args) {
         try {
             boolean isUuidEvent = UniqueEvent.class.isAssignableFrom(eventClass);
@@ -98,54 +97,138 @@ public class EventFlow {
         }
     }
 
-    /** Subscribe by ID: only fires if UUID matches this publisher's eventId. */
-    public <TT extends ResponseToUniqueEvent> EventFlow onResponse(
-            Class<TT> eventClass, Consumer<TT> action, boolean unsubscribeAfterSuccess) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
-        listenerHolder[0] =
-                new ListenerHandler(
-                        GlobalEventBus.subscribe(
-                                eventClass,
-                                event -> {
-                                    if (event.getIdentifier() != this.eventSnowflake) return;
-
-                                    action.accept(event);
-
-                                    if (unsubscribeAfterSuccess && listenerHolder[0] != null) {
-                                        GlobalEventBus.unsubscribe(listenerHolder[0]);
-                                        this.listeners.remove(listenerHolder[0]);
-                                    }
-
-                                    this.result = event.result();
-                                }));
-        this.listeners.add(listenerHolder[0]);
+    /**
+     *
+     * Add an event that will be triggered when {@link #postEvent()} or {@link #asyncPostEvent()} is called.
+     *
+     * @param event The event to be posted.
+     * @return {@link #EventFlow}
+     *
+     */
+    public EventFlow addPostEvent(EventType event) {
+        this.event = event;
         return this;
     }
 
-    /** Subscribe by ID: only fires if UUID matches this publisher's eventId. */
-    public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Class<TT> eventClass, Consumer<TT> action) {
-        return this.onResponse(eventClass, action, true);
+    /**
+     *
+     * Add an event that will be triggered when {@link #postEvent()} or {@link #asyncPostEvent()} is called.
+     *
+     * @param eventSupplier The event that will be posted through a Supplier.
+     * @return {@link #EventFlow}
+     *
+     */
+    public EventFlow addPostEvent(Supplier<? extends EventType> eventSupplier) {
+        this.event = eventSupplier.get();
+        return this;
     }
 
-    /** Subscribe by ID without explicit class. */
+    /**
+     *
+     * Start listening for an event and trigger when ID correlates.
+     *
+     * @param event The {@link ResponseToUniqueEvent} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @param unsubscribeAfterSuccess Enable/disable auto unsubscribing to event after being triggered.
+     * @param name A name given to the event, can later be used to unsubscribe.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends ResponseToUniqueEvent> EventFlow onResponse(
+            Class<TT> event, Consumer<TT> action, boolean unsubscribeAfterSuccess, String name
+    ) {
+
+        final long id = SnowflakeGenerator.nextId();
+
+        Consumer<TT> newAction = eventClass -> {
+            if (eventClass.getIdentifier() != this.eventSnowflake) return;
+
+            action.accept(eventClass);
+
+            if (unsubscribeAfterSuccess) unsubscribe(id);
+
+            this.result = eventClass.result();
+        };
+
+        // TODO Remove casts
+        var listener = new ListenerHandler<>(
+                id,
+                name,
+                (Class<ResponseToUniqueEvent>) event,
+                (Consumer<ResponseToUniqueEvent>) newAction
+        );
+
+        GlobalEventBus.subscribe(listener);
+        this.listeners.add(listener);
+        return this;
+    }
+
+    /**
+     *
+     * Start listening for an event and trigger when ID correlates, auto unsubscribes after being triggered and adds an empty name.
+     *
+     * @param event The {@link ResponseToUniqueEvent} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Class<TT> event, Consumer<TT> action) {
+        return this.onResponse(event, action, true, "");
+    }
+
+    /**
+     *
+     * Start listening for an event and trigger when ID correlates, auto adds an empty name.
+     *
+     * @param event The {@link ResponseToUniqueEvent} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @param unsubscribeAfterSuccess Enable/disable auto unsubscribing to event after being triggered.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Class<TT> event, Consumer<TT> action, boolean unsubscribeAfterSuccess) {
+        return this.onResponse(event, action, unsubscribeAfterSuccess, "");
+    }
+
+    /**
+     *
+     * Start listening for an event and trigger when ID correlates, auto unsubscribes after being triggered.
+     *
+     * @param event The {@link ResponseToUniqueEvent} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @param name A name given to the event, can later be used to unsubscribe.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Class<TT> event, Consumer<TT> action, String name) {
+        return this.onResponse(event, action, true, name);
+    }
+
+    /**
+     *
+     * Subscribe by ID without explicit class.
+     *
+     * @param action The lambda to run when triggered.
+     * @return {@link #EventFlow}
+     *
+     * @deprecated use {@link #onResponse(Class, Consumer, boolean, String)} instead.
+     */
+    @Deprecated
     @SuppressWarnings("unchecked")
     public <TT extends ResponseToUniqueEvent> EventFlow onResponse(
-            Consumer<TT> action, boolean unsubscribeAfterSuccess) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
-        listenerHolder[0] =
-                new ListenerHandler(
-                        GlobalEventBus.subscribe(
-                                event -> {
+            Consumer<TT> action, boolean unsubscribeAfterSuccess, String name) {
+
+        final long id = SnowflakeGenerator.nextId();
+
+        Consumer<TT> newAction = event -> {
             if (!(event instanceof UniqueEvent uuidEvent)) return;
             if (uuidEvent.getIdentifier() == this.eventSnowflake) {
                 try {
                     TT typedEvent = (TT) uuidEvent;
                     action.accept(typedEvent);
-                                            if (unsubscribeAfterSuccess
-                                                    && listenerHolder[0] != null) {
-                                                GlobalEventBus.unsubscribe(listenerHolder[0]);
-                                                this.listeners.remove(listenerHolder[0]);
-                                            }
+
+                    if (unsubscribeAfterSuccess) unsubscribe(id);
+
                     this.result = typedEvent.result();
                 } catch (ClassCastException _) {
                     throw new ClassCastException(
@@ -154,99 +237,281 @@ public class EventFlow {
                                     + " to UniqueEvent");
                 }
             }
-                                }));
-        this.listeners.add(listenerHolder[0]);
+        };
+
+        var listener = new ListenerHandler<>(
+                id,
+                name,
+                (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0],
+                newAction
+        );
+
+        GlobalEventBus.subscribe(listener);
+        this.listeners.add(listener);
         return this;
     }
 
+    /**
+     *
+     * Subscribe by ID without explicit class.
+     *
+     * @param action The lambda to run when triggered.
+     * @return {@link #EventFlow}
+     *
+     * @deprecated use {@link #onResponse(Class, Consumer)} instead.
+     */
+    @Deprecated
     public <TT extends ResponseToUniqueEvent> EventFlow onResponse(Consumer<TT> action) {
-        return this.onResponse(action, true);
+        return this.onResponse(action, true, "");
     }
 
+    /**
+     *
+     * Start listening for an event, and run a lambda when triggered.
+     *
+     * @param event The {@link EventType} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @param unsubscribeAfterSuccess Enable/disable auto unsubscribing to event after being triggered.
+     * @param name A name given to the event, can later be used to unsubscribe.
+     * @return {@link #EventFlow}
+     *
+     */
     public <TT extends EventType> EventFlow listen(
-            Class<TT> eventClass, Consumer<TT> action, boolean unsubscribeAfterSuccess) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
-        listenerHolder[0] =
-                new ListenerHandler(
-                        GlobalEventBus.subscribe(
-                                eventClass,
-                                event -> {
-                                    action.accept(event);
+            Class<TT> event, Consumer<TT> action, boolean unsubscribeAfterSuccess, String name) {
 
-                                    if (unsubscribeAfterSuccess && listenerHolder[0] != null) {
-                                        GlobalEventBus.unsubscribe(listenerHolder[0]);
-                                        this.listeners.remove(listenerHolder[0]);
-                                    }
-                                }));
-        this.listeners.add(listenerHolder[0]);
+        long id = SnowflakeGenerator.nextId();
+
+        Consumer<TT> newAction = eventc -> {
+            action.accept(eventc);
+
+            if (unsubscribeAfterSuccess) unsubscribe(id);
+        };
+
+        var listener = new ListenerHandler<>(
+                        id,
+                        name,
+                        event,
+                        newAction
+                );
+
+        GlobalEventBus.subscribe(listener);
+        this.listeners.add(listener);
         return this;
     }
 
-    public <TT extends EventType> EventFlow listen(Class<TT> eventClass, Consumer<TT> action) {
-        return this.listen(eventClass, action, true);
+    /**
+     *
+     * Start listening for an event, and run a lambda when triggered, auto unsubscribes.
+     *
+     * @param event The {@link EventType} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @param name A name given to the event, can later be used to unsubscribe.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends EventType> EventFlow listen(Class<TT> event, Consumer<TT> action, String name) {
+        return this.listen(event, action, true, name);
     }
 
+    /**
+     *
+     * Start listening for an event, and run a lambda when triggered, auto unsubscribe and gives it an empty name.
+     *
+     * @param event The {@link EventType} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends EventType> EventFlow listen(Class<TT> event, Consumer<TT> action) {
+        return this.listen(event, action, true, "");
+    }
+
+    /**
+     *
+     * Start listening for an event, and run a lambda when triggered, adds an empty name.
+     *
+     * @param event The {@link EventType} to trigger the lambda.
+     * @param action The lambda to run when triggered.
+     * @param unsubscribeAfterSuccess Enable/disable auto unsubscribing to event after being triggered.
+     * @return {@link #EventFlow}
+     *
+     */
+    public <TT extends EventType> EventFlow listen(Class<TT> event, Consumer<TT> action, boolean unsubscribeAfterSuccess) {
+        return this.listen(event, action, unsubscribeAfterSuccess, "");
+    }
+
+    /**
+     *
+     * Start listening to an event.
+     *
+     * @param action The lambda to run when triggered.
+     * @return {@link EventFlow}
+     *
+     * @deprecated use {@link #listen(Class, Consumer, boolean, String)} instead.
+     */
+    @Deprecated
     @SuppressWarnings("unchecked")
     public <TT extends EventType> EventFlow listen(
-            Consumer<TT> action, boolean unsubscribeAfterSuccess) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
-        listenerHolder[0] =
-                new ListenerHandler(
-                        GlobalEventBus.subscribe(
-                                event -> {
+            Consumer<TT> action, boolean unsubscribeAfterSuccess, String name) {
+        long id = SnowflakeGenerator.nextId();
+
+        Class<TT> eventClass = (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0];
+
+        Consumer<TT> newAction = event -> {
             if (!(event instanceof EventType nonUuidEvent)) return;
             try {
                 TT typedEvent = (TT) nonUuidEvent;
                 action.accept(typedEvent);
-                                        if (unsubscribeAfterSuccess && listenerHolder[0] != null) {
-                                            GlobalEventBus.unsubscribe(listenerHolder[0]);
-                                            this.listeners.remove(listenerHolder[0]);
-                                        }
+                if (unsubscribeAfterSuccess) unsubscribe(id);
             } catch (ClassCastException _) {
                 throw new ClassCastException(
                         "Cannot cast "
                                 + event.getClass().getName()
                                 + " to UniqueEvent");
             }
-                                }));
-        this.listeners.add(listenerHolder[0]);
+        };
+
+        var listener = new ListenerHandler<>(
+                id,
+                name,
+                eventClass,
+                newAction
+        );
+
+        GlobalEventBus.subscribe(listener);
+        this.listeners.add(listener);
         return this;
     }
 
+    /**
+     *
+     * Start listening to an event.
+     *
+     * @param action The lambda to run when triggered.
+     * @return {@link EventFlow}
+     *
+     * @deprecated use {@link #listen(Class, Consumer)} instead.
+     */
+    @Deprecated
     public <TT extends EventType> EventFlow listen(Consumer<TT> action) {
-        return this.listen(action, true);
+        return this.listen(action, true, "");
     }
 
-    /** Post synchronously */
+    /**
+     * Posts the event added through {@link #addPostEvent}.
+     */
     public EventFlow postEvent() {
         GlobalEventBus.post(this.event);
         return this;
     }
 
-    /** Post asynchronously */
+    /**
+     * Posts the event added through {@link #addPostEvent} asynchronously.
+     */
     public EventFlow asyncPostEvent() {
         GlobalEventBus.postAsync(this.event);
         return this;
     }
 
+    /**
+     *
+     * Unsubscribe from an event.
+     *
+     * @param listenerObject The listener object to remove and unsubscribe.
+     */
+    public void unsubscribe(Object listenerObject) {
+        this.listeners.removeIf(handler -> {
+            if (handler.getListener() == listenerObject) {
+                GlobalEventBus.unsubscribe(handler);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    /**
+     *
+     * Unsubscribe from an event.
+     *
+     * @param listenerId The id given to the {@link ListenerHandler}.
+     */
+    public void unsubscribe(long listenerId) {
+        this.listeners.removeIf(handler -> {
+            if (handler.getId() == listenerId) {
+                GlobalEventBus.unsubscribe(handler);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    /**
+     * Unsubscribe from an event.
+     *
+     * @param name The name given to the listener.
+     */
+    public void unsubscribe(String name) {
+        this.listeners.removeIf(handler -> {
+            if (handler.getName().equals(name)) {
+                GlobalEventBus.unsubscribe(handler);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    /**
+     * Unsubscribe all events.
+     */
+    public void unsubscribeAll() {
+        listeners.removeIf(handler -> {
+            GlobalEventBus.unsubscribe(handler);
+            return true;
+        });
+    }
+
+    /**
+     * Clean and remove everything inside {@link EventFlow}.
+     */
     private void clean() {
-        this.listeners.clear();
+        unsubscribeAll();
         this.event = null;
         this.result = null;
     } // TODO
 
+    /**
+     *  TODO
+     *
+     * @return TODO
+     */
     public Map<String, ?> getResult() {
         return this.result;
     }
 
+    /**
+     *  TODO
+     *
+     * @return TODO
+     */
     public EventType getEvent() {
         return event;
     }
 
+    /**
+     *
+     * Returns a copy of the list of listeners.
+     *
+     * @return Copy of the list of listeners.
+     */
     public ListenerHandler[] getListeners() {
         return listeners.toArray(new ListenerHandler[0]);
     }
 
+    /**
+     *  Returns the generated snowflake for the {@link EventFlow}
+     *
+     * @return The generated snowflake for this {@link EventFlow}
+     */
     public long getEventSnowflake() {
         return eventSnowflake;
     }

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

@@ -6,6 +6,9 @@ import com.lmax.disruptor.dsl.ProducerType;
 import java.util.Map;
 import java.util.concurrent.*;
 import java.util.function.Consumer;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.events.UniqueEvent;
 
@@ -14,9 +17,10 @@ import org.toop.framework.eventbus.events.UniqueEvent;
  * 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<Consumer<? super EventType>>>
+    private static final Map<Class<?>, CopyOnWriteArrayList<ListenerHandler<?>>>
             LISTENERS = new ConcurrentHashMap<>();
 
     /** Map of event class to Snowflake-ID-specific listeners. */
@@ -49,7 +53,6 @@ public final class GlobalEventBus {
                         ProducerType.MULTI,
                         new BusySpinWaitStrategy());
 
-        // Single consumer that dispatches to subscribers
         DISRUPTOR.handleEventsWith(
                 (holder, seq, endOfBatch) -> {
                     if (holder.event != null) {
@@ -73,23 +76,12 @@ public final class GlobalEventBus {
     // ------------------------------------------------------------------------
     // Subscription
     // ------------------------------------------------------------------------
-    public static <T extends EventType> Consumer<? super EventType> subscribe(
-            Class<T> eventClass, Consumer<T> listener) {
-
-        CopyOnWriteArrayList<Consumer<? super EventType>> list =
-                LISTENERS.computeIfAbsent(eventClass, k -> new CopyOnWriteArrayList<>());
-
-        Consumer<? super EventType> wrapper = event -> listener.accept(eventClass.cast(event));
-        list.add(wrapper);
-        return wrapper;
-    }
-
-    public static Consumer<? super EventType> subscribe(Consumer<Object> listener) {
-        Consumer<? super EventType> wrapper = event -> listener.accept(event);
-        LISTENERS.computeIfAbsent(Object.class, _ -> new CopyOnWriteArrayList<>()).add(wrapper);
-        return wrapper;
+    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);
     }
 
+    // TODO
     public static <T extends UniqueEvent> void subscribeById(
             Class<T> eventClass, long eventId, Consumer<T> listener) {
         UUID_LISTENERS
@@ -97,10 +89,14 @@ public final class GlobalEventBus {
                 .put(eventId, listener);
     }
 
-    public static void unsubscribe(Object listener) {
-        LISTENERS.values().forEach(list -> list.remove(listener));
+    public static void unsubscribe(ListenerHandler<?> listener) {
+        logger.debug("Unsubscribing from {}: {}", listener.getListenerClass().getSimpleName(), listener.getListener().getClass().getSimpleName());
+        LISTENERS.getOrDefault(listener.getListenerClass(), new CopyOnWriteArrayList<>())
+                .remove(listener);
+        LISTENERS.entrySet().removeIf(entry -> entry.getValue().isEmpty());
     }
 
+    // TODO
     public static <T extends UniqueEvent> void unsubscribeById(
             Class<T> eventClass, long eventId) {
         Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(eventClass);
@@ -124,36 +120,44 @@ public final class GlobalEventBus {
         }
     }
 
+    @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();
 
-        // class-specific listeners
-        CopyOnWriteArrayList<Consumer<? super EventType>> classListeners = LISTENERS.get(clazz);
+        logger.debug("Triggered event: {}", event.getClass().getSimpleName());
+
+        CopyOnWriteArrayList<ListenerHandler<?>> classListeners = LISTENERS.get(clazz);
         if (classListeners != null) {
-            for (Consumer<? super EventType> listener : classListeners) {
+            for (ListenerHandler<?> listener : classListeners) {
                 try {
-                    listener.accept(event);
+                    callListener(listener, event);
                 } catch (Throwable e) {
-//                    e.printStackTrace();
+                    e.printStackTrace();
                 }
             }
         }
 
-        // generic listeners
-        CopyOnWriteArrayList<Consumer<? super EventType>> genericListeners =
-                LISTENERS.get(Object.class);
+        CopyOnWriteArrayList<ListenerHandler<?>> genericListeners = LISTENERS.get(Object.class);
         if (genericListeners != null) {
-            for (Consumer<? super EventType> listener : genericListeners) {
+            for (ListenerHandler<?> listener : genericListeners) {
                 try {
-                    listener.accept(event);
+                    callListener(listener, event);
                 } catch (Throwable e) {
-                    // e.printStackTrace();
+                     e.printStackTrace();
                 }
             }
         }
 
-        // snowflake listeners
         if (event instanceof UniqueEvent snowflakeEvent) {
             Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(clazz);
             if (map != null) {
@@ -182,4 +186,8 @@ public final class GlobalEventBus {
         LISTENERS.clear();
         UUID_LISTENERS.clear();
     }
+
+    public static Map<Class<?>, CopyOnWriteArrayList<ListenerHandler<?>>> getAllListeners() {
+        return LISTENERS;
+    }
 }

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

@@ -1,25 +1,48 @@
 package org.toop.framework.eventbus;
 
-public class ListenerHandler {
-    private Object listener;
+import org.toop.framework.SnowflakeGenerator;
+import org.toop.framework.eventbus.events.EventType;
 
-    //    private boolean unsubscribeAfterSuccess = true;
+import java.util.function.Consumer;
 
-    //    public ListenerHandler(Object listener, boolean unsubAfterSuccess) {
-    //        this.listener = listener;
-    //        this.unsubscribeAfterSuccess = unsubAfterSuccess;
-    //    }
+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(Object 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 Object getListener() {
-        return this.listener;
+    public ListenerHandler(String name, Class<T> clazz, Consumer<T> listener) {
+        this(SnowflakeGenerator.nextId(), name, clazz, listener);
     }
 
-    //    public boolean isUnsubscribeAfterSuccess() {
-    //        return this.unsubscribeAfterSuccess;
-    //    }
-
+    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/gameFramework/GameState.java

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

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

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

framework/src/main/java/org/toop/framework/gameFramework/model/game/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/DeepCopyable.java

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

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

@@ -0,0 +1,12 @@
+package org.toop.framework.gameFramework.model.game;
+
+import org.toop.framework.gameFramework.GameState;
+
+/**
+ * Represents the result of a move in a turn-based game.
+ *
+ * @param state  the resulting {@link GameState} after the move
+ * @param player the index of the player associated with the result (winner or relevant player)
+ */
+public record PlayResult(GameState state, int player) {
+}

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

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

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

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

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

@@ -0,0 +1,20 @@
+package org.toop.framework.gameFramework.model.game;
+
+import org.toop.framework.networking.events.NetworkEvents;
+
+/**
+ * Interface for games that support online multiplayer play.
+ * <p>
+ * Methods are called in response to network events from the server.
+ */
+public interface SupportsOnlinePlay {
+
+    /** 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);
+}

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

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

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

@@ -0,0 +1,36 @@
+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.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.Player;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+
+/**
+ * Base class for thread-based game behaviours.
+ * <p>
+ * Provides common functionality for managing game state and execution:
+ * 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<T> {
+
+    /** Indicates whether the game loop or event processing is active. */
+    protected final AtomicBoolean isRunning = new AtomicBoolean();
+
+    /** The game instance controlled by this behaviour. */
+    protected final T game;
+
+    /** Logger for the subclass to report errors or debug info. */
+    protected final Logger logger = LogManager.getLogger(this.getClass());
+
+    /**
+     * Creates a new base behaviour for the specified game.
+     *
+     * @param game the turn-based game to control
+     */
+    public AbstractThreadBehaviour(T game) {
+        this.game = game;
+    }
+}

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

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

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

@@ -0,0 +1,13 @@
+package org.toop.framework.gameFramework.model.game.threadBehaviour;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+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<T extends TurnBasedGame<T>> extends Controllable {
+}

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

@@ -0,0 +1,17 @@
+package org.toop.framework.gameFramework.model.player;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+/**
+ * Abstract base class for AI implementations for games extending {@link GameR}.
+ * <p>
+ * Provides a common superclass for specific AI algorithms. Concrete subclasses
+ * must implement the {@link #findBestMove(GameR, int)} method defined by
+ * {@link IAIMoveR} to determine the best move given a game state and a search depth.
+ * </p>
+ *
+ * @param <T> the specific type of game this AI can play, extending {@link GameR}
+ */
+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

@@ -0,0 +1,48 @@
+package org.toop.framework.gameFramework.model.player;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+
+/**
+ * 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 String name;
+
+    protected AbstractPlayer(String name) {
+        this.name = name;
+    }
+    /**
+     * 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 gameCopy a snapshot of the current game state
+     * @return an integer representing the chosen move
+     * @throws UnsupportedOperationException if the method is not overridden
+     */
+    public int getMove(T gameCopy) {
+        logger.error("Method getMove not implemented.");
+        throw new UnsupportedOperationException("Not supported yet.");
+    }
+
+    public String getName(){
+        return this.name;
+    }
+}

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

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

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

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

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

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

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

@@ -0,0 +1,30 @@
+package org.toop.framework.gameFramework.view;
+
+import org.toop.framework.eventbus.events.EventsBase;
+import org.toop.framework.eventbus.events.GenericEvent;
+
+/**
+ * Defines GUI-related events for the event bus.
+ * <p>
+ * These events notify the UI about updates such as game progress,
+ * 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.
+     *
+     * @param winOrTie true if the game ended in a win, false for a draw
+     * @param winner the index of the winning player, or -1 if no winner
+     */
+    public record GameEnded(boolean winOrTie, int winner) implements GenericEvent {}
+
+    /** Event indicating a player has attempted a move. */
+    public record PlayerAttemptedMove(int move) implements GenericEvent {}
+
+    /** Event indicating a player is hovering over a move (for UI feedback). */
+    public record PlayerMoveHovered(int move) implements GenericEvent {}
+}

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

@@ -17,25 +17,25 @@ public class NetworkingClientEventListener {
     public NetworkingClientEventListener(NetworkingClientManager clientManager) {
         this.clientManager = clientManager;
         new EventFlow()
-                .listen(this::handleStartClient)
-                .listen(this::handleCommand)
-                .listen(this::handleSendLogin)
-                .listen(this::handleSendLogout)
-                .listen(this::handleSendGetPlayerlist)
-                .listen(this::handleSendGetGamelist)
-                .listen(this::handleSendSubscribe)
-                .listen(this::handleSendMove)
-                .listen(this::handleSendChallenge)
-                .listen(this::handleSendAcceptChallenge)
-                .listen(this::handleSendForfeit)
-                .listen(this::handleSendMessage)
-                .listen(this::handleSendHelp)
-                .listen(this::handleSendHelpForCommand)
-                .listen(this::handleCloseClient)
-                .listen(this::handleReconnect)
-                .listen(this::handleChangeAddress)
-                .listen(this::handleGetAllConnections)
-                .listen(this::handleShutdownAll);
+                .listen(NetworkEvents.StartClient.class, this::handleStartClient, false)
+                .listen(NetworkEvents.SendCommand.class, this::handleCommand, false)
+                .listen(NetworkEvents.SendLogin.class, this::handleSendLogin, false)
+                .listen(NetworkEvents.SendLogout.class, this::handleSendLogout, false)
+                .listen(NetworkEvents.SendGetPlayerlist.class, this::handleSendGetPlayerlist, false)
+                .listen(NetworkEvents.SendGetGamelist.class, this::handleSendGetGamelist, false)
+                .listen(NetworkEvents.SendSubscribe.class, this::handleSendSubscribe, false)
+                .listen(NetworkEvents.SendMove.class, this::handleSendMove, false)
+                .listen(NetworkEvents.SendChallenge.class, this::handleSendChallenge, false)
+                .listen(NetworkEvents.SendAcceptChallenge.class, this::handleSendAcceptChallenge, false)
+                .listen(NetworkEvents.SendForfeit.class, this::handleSendForfeit, false)
+                .listen(NetworkEvents.SendMessage.class, this::handleSendMessage, false)
+                .listen(NetworkEvents.SendHelp.class, this::handleSendHelp, false)
+                .listen(NetworkEvents.SendHelpForCommand.class, this::handleSendHelpForCommand, false)
+                .listen(NetworkEvents.CloseClient.class, this::handleCloseClient, false)
+                .listen(NetworkEvents.Reconnect.class, this::handleReconnect, false)
+                .listen(NetworkEvents.ChangeAddress.class, this::handleChangeAddress, false)
+                .listen(NetworkEvents.RequestsAllClients.class, this::handleGetAllConnections, false)
+                .listen(NetworkEvents.ForceCloseAllClients.class, this::handleShutdownAll, false);
     }
 
     void handleStartClient(NetworkEvents.StartClient event) {

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

@@ -8,6 +8,8 @@ import java.util.concurrent.TimeUnit;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+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;
 import org.toop.framework.networking.interfaces.NetworkingClient;
@@ -44,6 +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());
+                    GlobalEventBus.post(new NetworkEvents.ConnectTry(id, attempts, nConnector.reconnectAttempts(), true));
                     onSuccess.run();
                     scheduler.shutdown();
                 } catch (CouldNotConnectException e) {
@@ -51,14 +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());
+                        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);
+                        GlobalEventBus.post(new NetworkEvents.ConnectTry(id, -1, nConnector.reconnectAttempts(), false));
                         onFailure.run();
                         scheduler.shutdown();
                     }
                 } catch (Exception e) {
                     logger.error("Unexpected exception during startClient", e);
+                    GlobalEventBus.post(new NetworkEvents.ConnectTry(id, -1, nConnector.reconnectAttempts(), false));
                     onFailure.run();
                     scheduler.shutdown();
                 }

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

@@ -181,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

@@ -2,6 +2,8 @@ package org.toop.framework.networking.handlers;
 
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.channel.ChannelInboundHandlerAdapter;
+
+import java.util.regex.MatchResult;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
 import org.apache.logging.log4j.LogManager;
@@ -70,7 +72,7 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
                 case "CHALLENGE":
                     gameChallengeHandler(recSrvRemoved);
                     return;
-                case "WIN", "DRAW", "LOSE":
+                case "WIN", "DRAW", "LOSS":
                     gameWinConditionHandler(recSrvRemoved);
                     return;
                 default:
@@ -119,13 +121,12 @@ public class NetworkingGameClientHandler extends ChannelInboundHandlerAdapter {
     }
 
     private void gameWinConditionHandler(String rec) {
-        @SuppressWarnings("StreamToString")
-        String condition =
-                Pattern.compile("\\b(win|draw|lose)\\b", Pattern.CASE_INSENSITIVE)
+        String condition = Pattern.compile("\\b(win|draw|loss)\\b", Pattern.CASE_INSENSITIVE)
                 .matcher(rec)
                 .results()
-                        .toString()
-                        .trim();
+                .map(MatchResult::group)
+                .findFirst()
+                .orElse("");
 
         new EventFlow()
                 .addPostEvent(new NetworkEvents.GameResultResponse(this.connectionId, condition))

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

@@ -1,235 +1,222 @@
-// package org.toop.framework.eventbus;
-//
-// import org.junit.jupiter.api.Tag;
-// import org.junit.jupiter.api.Test;
-// import org.toop.framework.eventbus.events.UniqueEvent;
-//
-// import java.math.BigInteger;
-// import java.util.concurrent.*;
-// import java.util.concurrent.atomic.LongAdder;
-//
-// import static org.junit.jupiter.api.Assertions.assertEquals;
-//
-// class EventFlowStressTest {
-//
-//    /** Top-level record to ensure runtime type matches subscription */
-//    public record HeavyEvent(String payload, long eventSnowflake) implements UniqueEvent {
-//        @Override
-//        public java.util.Map<String, Object> result() {
-//            return java.util.Map.of("payload", payload, "eventId", eventSnowflake);
-//        }
-//
-//        @Override
-//        public long eventSnowflake() {
-//            return this.eventSnowflake;
-//        }
-//    }
-//
-//    public record HeavyEventSuccess(String payload, long eventSnowflake) implements
-// UniqueEvent {
-//        @Override
-//        public java.util.Map<String, Object> result() {
-//            return java.util.Map.of("payload", payload, "eventId", eventSnowflake);
-//        }
-//
-//        @Override
-//        public long eventSnowflake() {
-//            return eventSnowflake;
-//        }
-//    }
-//
-//    private static final int THREADS = 32;
-//    private static final long EVENTS_PER_THREAD = 10_000_000;
-//
-//    @Tag("stress")
-//    @Test
-//    void extremeConcurrencySendTest_progressWithMemory() throws InterruptedException {
-//        LongAdder counter = new LongAdder();
-//        ExecutorService executor = Executors.newFixedThreadPool(THREADS);
-//
-//        BigInteger totalEvents = BigInteger.valueOf(THREADS)
-//                .multiply(BigInteger.valueOf(EVENTS_PER_THREAD));
-//
-//        long startTime = System.currentTimeMillis();
-//
-//        // Monitor thread for EPS and memory
-//        Thread monitor = new Thread(() -> {
-//            long lastCount = 0;
-//            long lastTime = System.currentTimeMillis();
-//            Runtime runtime = Runtime.getRuntime();
-//
-//            while (counter.sum() < totalEvents.longValue()) {
-//                try { Thread.sleep(200); } catch (InterruptedException ignored) {}
-//
-//                long now = System.currentTimeMillis();
-//                long completed = counter.sum();
-//                long eventsThisPeriod = completed - lastCount;
-//                double eps = eventsThisPeriod / ((now - lastTime) / 1000.0);
-//
-//                long usedMemory = runtime.totalMemory() - runtime.freeMemory();
-//                double usedPercent = usedMemory * 100.0 / runtime.maxMemory();
-//
-//                System.out.printf(
-//                        "Progress: %d/%d (%.2f%%), EPS: %.0f, Memory Used: %.2f MB (%.2f%%)%n",
-//                        completed,
-//                        totalEvents.longValue(),
-//                        completed * 100.0 / totalEvents.doubleValue(),
-//                        eps,
-//                        usedMemory / 1024.0 / 1024.0,
-//                        usedPercent
-//                );
-//
-//                lastCount = completed;
-//                lastTime = now;
-//            }
-//        });
-//        monitor.setDaemon(true);
-//        monitor.start();
-//
-//        var listener = new EventFlow().listen(HeavyEvent.class, _ -> counter.increment());
-//
-//        // Submit events asynchronously
-//        for (int t = 0; t < THREADS; t++) {
-//            executor.submit(() -> {
-//                for (int i = 0; i < EVENTS_PER_THREAD; i++) {
-//                    var _ = new EventFlow().addPostEvent(HeavyEvent.class, "payload-" + i)
-//                            .asyncPostEvent();
-//                }
-//            });
-//        }
-//
-//        executor.shutdown();
-//        executor.awaitTermination(10, TimeUnit.MINUTES);
-//
-//        listener.getResult();
-//
-//        long endTime = System.currentTimeMillis();
-//        double durationSeconds = (endTime - startTime) / 1000.0;
-//
-//        System.out.println("Posted " + totalEvents + " events in " + durationSeconds + "
-// seconds");
-//        double averageEps = totalEvents.doubleValue() / durationSeconds;
-//        System.out.printf("Average EPS: %.0f%n", averageEps);
-//
-//        assertEquals(totalEvents.longValue(), counter.sum());
-//    }
-//
-//    @Tag("stress")
-//    @Test
-//    void extremeConcurrencySendAndReturnTest_progressWithMemory() throws InterruptedException {
-//        LongAdder counter = new LongAdder();
-//        ExecutorService executor = Executors.newFixedThreadPool(THREADS);
-//
-//        BigInteger totalEvents = BigInteger.valueOf(THREADS)
-//                .multiply(BigInteger.valueOf(EVENTS_PER_THREAD));
-//
-//        long startTime = System.currentTimeMillis();
-//
-//        // Monitor thread for EPS and memory
-//        Thread monitor = new Thread(() -> {
-//            long lastCount = 0;
-//            long lastTime = System.currentTimeMillis();
-//            Runtime runtime = Runtime.getRuntime();
-//
-//            while (counter.sum() < totalEvents.longValue()) {
-//                try { Thread.sleep(200); } catch (InterruptedException ignored) {}
-//
-//                long now = System.currentTimeMillis();
-//                long completed = counter.sum();
-//                long eventsThisPeriod = completed - lastCount;
-//                double eps = eventsThisPeriod / ((now - lastTime) / 1000.0);
-//
-//                long usedMemory = runtime.totalMemory() - runtime.freeMemory();
-//                double usedPercent = usedMemory * 100.0 / runtime.maxMemory();
-//
-//                System.out.printf(
-//                        "Progress: %d/%d (%.2f%%), EPS: %.0f, Memory Used: %.2f MB (%.2f%%)%n",
-//                        completed,
-//                        totalEvents.longValue(),
-//                        completed * 100.0 / totalEvents.doubleValue(),
-//                        eps,
-//                        usedMemory / 1024.0 / 1024.0,
-//                        usedPercent
-//                );
-//
-//                lastCount = completed;
-//                lastTime = now;
-//            }
-//        });
-//        monitor.setDaemon(true);
-//        monitor.start();
-//
-//        // Submit events asynchronously
-//        for (int t = 0; t < THREADS; t++) {
-//            executor.submit(() -> {
-//                for (int i = 0; i < EVENTS_PER_THREAD; i++) {
-//                    var a = new EventFlow().addPostEvent(HeavyEvent.class, "payload-" + i)
-//                            .onResponse(HeavyEventSuccess.class, _ -> counter.increment())
-//                            .postEvent();
-//
-//                    new EventFlow().addPostEvent(HeavyEventSuccess.class, "payload-" + i,
-// a.getEventSnowflake())
-//                            .postEvent();
-//                }
-//            });
-//        }
-//
-//        executor.shutdown();
-//        executor.awaitTermination(10, TimeUnit.MINUTES);
-//
-//        long endTime = System.currentTimeMillis();
-//        double durationSeconds = (endTime - startTime) / 1000.0;
-//
-//        System.out.println("Posted " + totalEvents + " events in " + durationSeconds + "
-// seconds");
-//        double averageEps = totalEvents.doubleValue() / durationSeconds;
-//        System.out.printf("Average EPS: %.0f%n", averageEps);
-//
-//        assertEquals(totalEvents.longValue(), counter.sum());
-//    }
-//
-//
-//    @Tag("stress")
-//    @Test
-//    void efficientExtremeConcurrencyTest() throws InterruptedException {
-//        final int THREADS = Runtime.getRuntime().availableProcessors();
-//        final int EVENTS_PER_THREAD = 5000;
-//
-//        ExecutorService executor = Executors.newFixedThreadPool(THREADS);
-//        ConcurrentLinkedQueue<HeavyEvent> processedEvents = new ConcurrentLinkedQueue<>();
-//
-//        long start = System.nanoTime();
-//
-//        for (int t = 0; t < THREADS; t++) {
-//            executor.submit(() -> {
-//                for (int i = 0; i < EVENTS_PER_THREAD; i++) {
-//                    new EventFlow().addPostEvent(HeavyEvent.class, "payload-" + i)
-//                            .onResponse(HeavyEvent.class, processedEvents::add)
-//                            .postEvent();
-//                }
-//            });
-//        }
-//
-//        executor.shutdown();
-//        executor.awaitTermination(10, TimeUnit.MINUTES);
-//
-//        long end = System.nanoTime();
-//        double durationSeconds = (end - start) / 1_000_000_000.0;
-//
-//        BigInteger totalEvents = BigInteger.valueOf((long)
-// THREADS).multiply(BigInteger.valueOf(EVENTS_PER_THREAD));
-//        double eps = totalEvents.doubleValue() / durationSeconds;
-//
-//        System.out.printf("Posted %s events in %.3f seconds%n", totalEvents, durationSeconds);
-//        System.out.printf("Throughput: %.0f events/sec%n", eps);
-//
-//        Runtime rt = Runtime.getRuntime();
-//        System.out.printf("Used memory: %.2f MB%n", (rt.totalMemory() - rt.freeMemory()) / 1024.0
-// / 1024.0);
-//
-//        assertEquals(totalEvents.intValue(), processedEvents.size());
-//    }
-//
+ package org.toop.framework.eventbus;
+
+ import org.junit.jupiter.api.Tag;
+ import org.junit.jupiter.api.Test;
+ import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
+
+ import java.math.BigInteger;
+ import java.util.concurrent.*;
+ import java.util.concurrent.atomic.LongAdder;
+
+ import static org.junit.jupiter.api.Assertions.assertEquals;
+
+ class EventFlowStressTest {
+
+     public record HeavyEvent(String payload, long eventSnowflake) implements ResponseToUniqueEvent {
+         @Override
+         public long getIdentifier() {
+             return eventSnowflake;
+         }
+     }
+
+     public record HeavyEventSuccess(String payload, long eventSnowflake) implements ResponseToUniqueEvent {
+         @Override
+         public long getIdentifier() {
+             return eventSnowflake;
+         }
+     }
+
+    private static final int THREADS = 32;
+    private static final long EVENTS_PER_THREAD = 10_000_000;
+
+    @Tag("stress")
+    @Test
+    void extremeConcurrencySendTest_progressWithMemory() throws InterruptedException {
+        LongAdder counter = new LongAdder();
+        ExecutorService executor = Executors.newFixedThreadPool(THREADS);
+
+        BigInteger totalEvents = BigInteger.valueOf(THREADS)
+                .multiply(BigInteger.valueOf(EVENTS_PER_THREAD));
+
+        long startTime = System.currentTimeMillis();
+
+        Thread monitor = new Thread(() -> {
+            long lastCount = 0;
+            long lastTime = System.currentTimeMillis();
+            Runtime runtime = Runtime.getRuntime();
+
+            while (counter.sum() < totalEvents.longValue()) {
+                try { Thread.sleep(200); } catch (InterruptedException ignored) {}
+
+                long now = System.currentTimeMillis();
+                long completed = counter.sum();
+                long eventsThisPeriod = completed - lastCount;
+                double eps = eventsThisPeriod / ((now - lastTime) / 1000.0);
+
+                long usedMemory = runtime.totalMemory() - runtime.freeMemory();
+                double usedPercent = usedMemory * 100.0 / runtime.maxMemory();
+
+                System.out.printf(
+                        "Progress: %d/%d (%.2f%%), EPS: %.0f, Memory Used: %.2f MB (%.2f%%)%n",
+                        completed,
+                        totalEvents.longValue(),
+                        completed * 100.0 / totalEvents.doubleValue(),
+                        eps,
+                        usedMemory / 1024.0 / 1024.0,
+                        usedPercent
+                );
+
+                lastCount = completed;
+                lastTime = now;
+            }
+        });
+        monitor.setDaemon(true);
+        monitor.start();
+
+        var listener = new EventFlow().listen(HeavyEvent.class, _ -> counter.increment());
+
+        for (int t = 0; t < THREADS; t++) {
+            executor.submit(() -> {
+                for (int i = 0; i < EVENTS_PER_THREAD; i++) {
+                    var _ = new EventFlow().addPostEvent(HeavyEvent.class, "payload-" + i)
+                            .asyncPostEvent();
+                }
+            });
+        }
+
+        executor.shutdown();
+        executor.awaitTermination(10, TimeUnit.MINUTES);
+
+        listener.getResult();
+
+        long endTime = System.currentTimeMillis();
+        double durationSeconds = (endTime - startTime) / 1000.0;
+
+        System.out.println("Posted " + totalEvents + " events in " + durationSeconds + " seconds");
+        double averageEps = totalEvents.doubleValue() / durationSeconds;
+        System.out.printf("Average EPS: %.0f%n", averageEps);
+
+        assertEquals(totalEvents.longValue(), counter.sum());
+    }
+
+     @Tag("stress")
+     @Test
+     void extremeConcurrencySendAndReturnTest_progressWithMemory() throws InterruptedException {
+         LongAdder counter = new LongAdder();
+         ExecutorService executor = Executors.newFixedThreadPool(THREADS);
+
+         BigInteger totalEvents = BigInteger.valueOf(THREADS)
+                 .multiply(BigInteger.valueOf(EVENTS_PER_THREAD));
+
+         long startTime = System.currentTimeMillis();
+
+         Thread monitor = new Thread(() -> {
+             long lastCount = 0;
+             long lastTime = System.currentTimeMillis();
+             Runtime runtime = Runtime.getRuntime();
+
+             while (counter.sum() < totalEvents.longValue()) {
+                 try { Thread.sleep(500); } catch (InterruptedException ignored) {}
+
+                 long now = System.currentTimeMillis();
+                 long completed = counter.sum();
+                 long eventsThisPeriod = completed - lastCount;
+                 double eps = eventsThisPeriod / ((now - lastTime) / 1000.0);
+
+                 long usedMemory = runtime.totalMemory() - runtime.freeMemory();
+                 double usedPercent = usedMemory * 100.0 / runtime.maxMemory();
+
+                 System.out.printf(
+                         "Progress: %d/%d (%.2f%%), EPS: %.0f, Memory Used: %.2f MB (%.2f%%)%n",
+                         completed,
+                         totalEvents.longValue(),
+                         completed * 100.0 / totalEvents.doubleValue(),
+                         eps,
+                         usedMemory / 1024.0 / 1024.0,
+                         usedPercent
+                 );
+
+                 lastCount = completed;
+                 lastTime = now;
+             }
+         });
+         monitor.setDaemon(true);
+         monitor.start();
+
+         EventFlow sharedFlow = new EventFlow();
+         sharedFlow.listen(HeavyEventSuccess.class, _ -> counter.increment(), false, "heavyEventSuccessListener");
+
+         for (int t = 0; t < THREADS; t++) {
+             executor.submit(() -> {
+                 EventFlow threadFlow = new EventFlow();
+
+                 for (int i = 0; i < EVENTS_PER_THREAD; i++) {
+                     var heavyEvent = threadFlow.addPostEvent(HeavyEvent.class, "payload-" + i)
+                             .postEvent();
+
+                     threadFlow.addPostEvent(HeavyEventSuccess.class, "payload-" + i, heavyEvent.getEventSnowflake())
+                             .postEvent();
+                 }
+             });
+         }
+
+         executor.shutdown();
+         executor.awaitTermination(10, TimeUnit.MINUTES);
+
+         long endTime = System.currentTimeMillis();
+         double durationSeconds = (endTime - startTime) / 1000.0;
+
+         System.out.println("Posted " + totalEvents + " events in " + durationSeconds + " seconds");
+         double averageEps = totalEvents.doubleValue() / durationSeconds;
+         System.out.printf("Average EPS: %.0f%n", averageEps);
+
+         assertEquals(totalEvents.longValue(), counter.sum());
+     }
+
+     @Tag("stress")
+     @Test
+     void efficientExtremeConcurrencyTest() throws InterruptedException {
+         final int THREADS = Runtime.getRuntime().availableProcessors();
+         final int EVENTS_PER_THREAD = 1_000_000;
+
+         ExecutorService executor = Executors.newFixedThreadPool(THREADS);
+         ConcurrentLinkedQueue<HeavyEvent> processedEvents = new ConcurrentLinkedQueue<>();
+
+         long start = System.nanoTime();
+
+         EventFlow sharedFlow = new EventFlow();
+         sharedFlow.listen(HeavyEvent.class, processedEvents::add, false, "heavyEventListener");
+
+         for (int t = 0; t < THREADS; t++) {
+             executor.submit(() -> {
+                 EventFlow threadFlow = new EventFlow();
+
+                 for (int i = 0; i < EVENTS_PER_THREAD; i++) {
+                     threadFlow.addPostEvent(HeavyEvent.class, "payload-" + i)
+                             .postEvent();
+                 }
+             });
+         }
+
+         executor.shutdown();
+         executor.awaitTermination(10, TimeUnit.MINUTES);
+
+         long end = System.nanoTime();
+         double durationSeconds = (end - start) / 1_000_000_000.0;
+
+         BigInteger totalEvents = BigInteger.valueOf(THREADS)
+                 .multiply(BigInteger.valueOf(EVENTS_PER_THREAD));
+         double eps = totalEvents.doubleValue() / durationSeconds;
+
+         System.out.printf("Posted %s events in %.3f seconds%n", totalEvents, durationSeconds);
+         System.out.printf("Throughput: %.0f events/sec%n", eps);
+
+         Runtime rt = Runtime.getRuntime();
+         System.out.printf("Used memory: %.2f MB%n", (rt.totalMemory() - rt.freeMemory()) / 1024.0 / 1024.0);
+
+         assertEquals(totalEvents.intValue(), processedEvents.size());
+     }
+
 //    @Tag("stress")
 //    @Test
 //    void constructorCacheVsReflection() throws Throwable {
@@ -247,7 +234,6 @@
 //        long endHandle = System.nanoTime();
 //
 //        System.out.println("Reflection: " + (endReflect - startReflect) / 1_000_000 + " ms");
-//        System.out.println("MethodHandle Cache: " + (endHandle - startHandle) / 1_000_000 + "
-// ms");
-//    }
+//        System.out.println("MethodHandle Cache: " + (endHandle - startHandle) / 1_000_000 + " ms");
 //    }
+ }

game/pom.xml

@@ -99,6 +99,12 @@
             <artifactId>error_prone_annotations</artifactId>
             <version>2.42.0</version>
         </dependency>
+        <dependency>
+            <groupId>org.toop</groupId>
+            <artifactId>framework</artifactId>
+            <version>0.1</version>
+            <scope>compile</scope>
+        </dependency>
 
     </dependencies>
 

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

@@ -1,6 +0,0 @@
-package org.toop.game;
-
-import org.toop.game.interfaces.IAIMove;
-
-public abstract class AI<T extends Game> implements IAIMove<T> {
-}

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

@@ -1,116 +0,0 @@
-package org.toop.game.Connect4;
-
-import org.toop.game.TurnBasedGame;
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-
-import java.util.ArrayList;
-
-public class Connect4 extends TurnBasedGame {
-    private int movesLeft;
-
-    public Connect4() {
-        super(6, 7, 2);
-        movesLeft = this.getBoard().length;
-    }
-
-    public Connect4(Connect4 other) {
-        super(other);
-        movesLeft = other.movesLeft;
-    }
-
-    @Override
-    public Move[] getLegalMoves() {
-        final ArrayList<Move> legalMoves = new ArrayList<>();
-        final char currentValue = getCurrentValue();
-
-        for (int i = 0; i < this.getColumnSize(); i++) {
-            if (this.getBoard()[i] == EMPTY) {
-                legalMoves.add(new Move(i, currentValue));
-            }
-        }
-        return legalMoves.toArray(new Move[0]);
-    }
-
-    @Override
-    public GameState play(Move move) {
-        assert move != null;
-        assert move.position() >= 0 && move.position() < this.getBoard().length;
-        assert move.value() == getCurrentValue();
-
-        int lowestEmptySpot = move.position();
-        for (int i = 0; i < this.getRowSize(); i++) {
-            int checkMovePosition = move.position() + this.getColumnSize() * i;
-            if (checkMovePosition < this.getBoard().length) {
-                if  (this.getBoard()[checkMovePosition] == EMPTY) {
-                    lowestEmptySpot = checkMovePosition;
-                }
-            }
-        }
-        this.getBoard()[lowestEmptySpot] = move.value();
-        movesLeft--;
-
-        if (checkForWin()) {
-            return GameState.WIN;
-        }
-
-        nextTurn();
-
-
-        return GameState.NORMAL;
-    }
-
-    private boolean checkForWin() {
-        char[][] boardGrid = makeBoardAGrid();
-
-        for (int row = 0; row < this.getRowSize(); row++) {
-            for (int col = 0; col < this.getColumnSize(); col++) {
-                char cell = boardGrid[row][col];
-                if (cell == ' ' || cell == 0) continue;
-
-                if (col + 3 < this.getColumnSize() &&
-                        cell == boardGrid[row][col + 1] &&
-                        cell == boardGrid[row][col + 2] &&
-                        cell == boardGrid[row][col + 3]) {
-                    return true;
-                }
-
-                if (row + 3 < this.getRowSize() &&
-                        cell == boardGrid[row + 1][col] &&
-                        cell == boardGrid[row + 2][col] &&
-                        cell == boardGrid[row + 3][col]) {
-                    return true;
-                }
-
-                if (row + 3 < this.getRowSize() && col + 3 < this.getColumnSize() &&
-                        cell == boardGrid[row + 1][col + 1] &&
-                        cell == boardGrid[row + 2][col + 2] &&
-                        cell == boardGrid[row + 3][col + 3]) {
-                    return true;
-                }
-
-                if (row + 3 < this.getRowSize() && col - 3 >= 0 &&
-                        cell == boardGrid[row + 1][col - 1] &&
-                        cell == boardGrid[row + 2][col - 2] &&
-                        cell == boardGrid[row + 3][col - 3]) {
-                    return true;
-                }
-            }
-        }
-        return false;
-    }
-
-    private char[][] makeBoardAGrid() {
-        char[][] boardGrid = new char[this.getRowSize()][this.getColumnSize()];
-        for (int i = 0; i < this.getRowSize()*this.getColumnSize(); i++) {
-            boardGrid[i / this.getColumnSize()][i % this.getColumnSize()] = this.getBoard()[i];     //this.getBoard()Grid[y -> row] [x -> column]
-        }
-        return boardGrid;
-    }
-
-    private char getCurrentValue() {
-        return this.getCurrentTurn() == 0 ? 'X' : 'O';
-    }
-}
-
-

game/src/main/java/org/toop/game/Connect4/Connect4AI.java

@@ -1,63 +0,0 @@
-package org.toop.game.Connect4;
-
-import org.toop.game.AI;
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-
-public class Connect4AI extends AI<Connect4> {
-
-
-    public Move findBestMove(Connect4 game, int depth) {
-        assert game != null;
-        assert depth >= 0;
-
-        final Move[] legalMoves = game.getLegalMoves();
-
-        if (legalMoves.length <= 0) {
-            return null;
-        }
-
-        int bestScore = -depth;
-        Move bestMove = null;
-
-        for (final Move move : legalMoves) {
-            final int score = getMoveScore(game, depth, move, true);
-
-            if (score > bestScore) {
-                bestMove = move;
-                bestScore = score;
-            }
-        }
-
-        return bestMove != null? bestMove : legalMoves[(int)(Math.random() * legalMoves.length)];
-    }
-
-    private int getMoveScore(Connect4 game, int depth, Move move, boolean maximizing) {
-        final Connect4 copy = new Connect4(game);
-        final GameState state = copy.play(move);
-
-        switch (state) {
-            case GameState.DRAW: return 0;
-            case GameState.WIN: return maximizing? depth + 1 : -depth - 1;
-        }
-
-        if (depth <= 0) {
-            return 0;
-        }
-
-        final Move[] legalMoves = copy.getLegalMoves();
-        int score = maximizing? depth + 1 : -depth - 1;
-
-        for (final Move 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/Game.java

@@ -1,40 +0,0 @@
-package org.toop.game;
-
-import org.toop.game.interfaces.IPlayable;
-import org.toop.game.records.Move;
-
-import java.util.Arrays;
-
-public abstract class Game implements IPlayable {
-
-	public static final char EMPTY = (char)0; // Constant
-
-    private final int rowSize;
-    private final int columnSize;
-    private final char[] board;
-
-    protected Game(int rowSize, int columnSize) {
-        assert rowSize > 0 && columnSize > 0;
-
-        this.rowSize = rowSize;
-        this.columnSize = columnSize;
-
-        board = new char[rowSize * columnSize];
-        Arrays.fill(board, EMPTY);
-    }
-
-    protected Game(Game other) {
-        rowSize = other.rowSize;
-        columnSize = other.columnSize;
-        board = Arrays.copyOf(other.board, other.board.length);
-    }
-
-    public int getRowSize() {return this.rowSize;}
-
-    public int getColumnSize() {return this.columnSize;}
-
-    public char[] getBoard() {return this.board;}
-
-    protected void setBoard(Move move){this.board[move.position()] = move.value();}
-
-}

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

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

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

@@ -1,25 +0,0 @@
-package org.toop.game;
-
-public abstract class TurnBasedGame extends Game {
-    private final int playerCount;  // How many players are playing
-    private int turn = 0;           // What turn it is in the game
-
-    protected TurnBasedGame(int rowSize, int columnSize, int playerCount) {
-        super(rowSize, columnSize);
-        this.playerCount = playerCount;
-    }
-
-    protected TurnBasedGame(TurnBasedGame other) {
-        super(other);
-        playerCount = other.playerCount;
-        turn = other.turn;
-    }
-
-    protected void nextTurn() {
-        turn += 1;
-    }
-
-    public int getCurrentTurn() {
-        return turn % playerCount;
-    }
-}

game/src/main/java/org/toop/game/enumerators/GameState.java

@@ -1,9 +0,0 @@
-package org.toop.game.enumerators;
-
-public enum GameState {
-        NORMAL,
-        DRAW,
-        WIN,
-
-        TURN_SKIPPED,
-}

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

@@ -0,0 +1,89 @@
+package org.toop.game.gameThreads;
+
+import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.game.PlayResult;
+import org.toop.framework.gameFramework.model.game.threadBehaviour.AbstractThreadBehaviour;
+import org.toop.framework.gameFramework.view.GUIEvents;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.Player;
+
+/**
+ * Handles local turn-based game logic at a fixed update rate.
+ * <p>
+ * Runs a separate thread that executes game turns at a fixed frequency (default 60 updates/sec),
+ * applying player moves, updating the game state, and dispatching UI events.
+ */
+public class LocalFixedRateThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements Runnable {
+
+    /** All players participating in the game. */
+    private final Player<T>[] players;
+
+    /**
+     * Creates a fixed-rate behaviour for a local turn-based game.
+     *
+     * @param game    the game instance
+     * @param players the list of players in turn order
+     */
+    public LocalFixedRateThreadBehaviour(T game, Player<T>[] players) {
+        super(game);
+        this.players = players;
+    }
+
+    /** Starts the game loop thread if not already running. */
+    @Override
+    public void start() {
+        if (isRunning.compareAndSet(false, true)) {
+            new Thread(this).start();
+        }
+    }
+
+    /** Stops the game loop after the current iteration. */
+    @Override
+    public void stop() {
+        isRunning.set(false);
+    }
+
+    /**
+     * Main loop running at a fixed rate.
+     * <p>
+     * Fetches the current player's move, applies it to the game,
+     * updates the UI, and handles game-ending states.
+     */
+    @Override
+    public void run() {
+        final int UPS = 60;
+        final long UPDATE_INTERVAL = 1_000_000_000L / UPS;
+        long nextUpdate = System.nanoTime();
+
+        while (isRunning.get()) {
+            long now = System.nanoTime();
+            if (now >= nextUpdate) {
+                nextUpdate += UPDATE_INTERVAL;
+
+                Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
+                int move = currentPlayer.getMove(game.deepCopy());
+                PlayResult result = game.play(move);
+                new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+
+                GameState state = result.state();
+                switch (state) {
+                    case WIN, DRAW -> {
+                        isRunning.set(false);
+                        new EventFlow().addPostEvent(GUIEvents.GameEnded.class, state == GameState.WIN, result.player()).postEvent();
+                    }
+                    case NORMAL, TURN_SKIPPED -> { /* continue */ }
+                    default -> {
+                        logger.error("Unexpected state {}", state);
+                        isRunning.set(false);
+                        throw new RuntimeException("Unknown state: " + state);
+                    }
+                }
+            } else {
+                try {
+                    Thread.sleep(10);
+                } catch (InterruptedException ignored) {}
+            }
+        }
+    }
+}

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

@@ -0,0 +1,74 @@
+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.PlayResult;
+import org.toop.framework.gameFramework.GameState;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.Player;
+
+/**
+ * Handles local turn-based game logic in its own thread.
+ * <p>
+ * Repeatedly gets the current player's move, applies it to the game,
+ * updates the UI, and stops when the game ends or {@link #stop()} is called.
+ */
+public class LocalThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements Runnable {
+
+    /**
+     * Creates a new behaviour for a local turn-based game.
+     *
+     * @param game    the game instance
+     * @param players the list of players in turn order
+     */
+    public LocalThreadBehaviour(T game, Player<T>[] players) {
+        super(game);
+    }
+
+    /** Starts the game loop in a new thread. */
+    @Override
+    public void start() {
+        if (isRunning.compareAndSet(false, true)) {
+            new Thread(this).start();
+        }
+    }
+
+    /** Stops the game loop after the current iteration. */
+    @Override
+    public void stop() {
+        isRunning.set(false);
+    }
+
+    /**
+     * Main game loop: gets the current player's move, applies it,
+     * updates the UI, and handles end-of-game states.
+     */
+    @Override
+    public void run() {
+        while (isRunning.get()) {
+            Player<T> currentPlayer = game.getPlayer(game.getCurrentTurn());
+            int move = currentPlayer.getMove(game.deepCopy());
+            PlayResult result = game.play(move);
+            new EventFlow().addPostEvent(GUIEvents.RefreshGameCanvas.class).postEvent();
+
+            GameState state = result.state();
+            switch (state) {
+                case WIN, DRAW -> {
+                    isRunning.set(false);
+                    new EventFlow().addPostEvent(
+                            GUIEvents.GameEnded.class,
+                            state == GameState.WIN,
+                            result.player()
+                    ).postEvent();
+                }
+                case NORMAL, TURN_SKIPPED -> { /* continue normally */ }
+                default -> {
+                    logger.error("Unexpected state {}", state);
+                    isRunning.set(false);
+                    throw new RuntimeException("Unknown state: " + state);
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,95 @@
+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;
+
+/**
+ * Handles online multiplayer game logic.
+ * <p>
+ * Reacts to server events, sending moves and updating the game state
+ * for the local player while receiving moves from other players.
+ */
+public class OnlineThreadBehaviour<T extends TurnBasedGame<T>> extends AbstractThreadBehaviour<T> implements SupportsOnlinePlay {
+
+    /** 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, Player<T>[] players) {
+        super(game);
+        this.playerTurn = getFirstNotOnlinePlayer(players);
+        this.mainPlayer = players[this.playerTurn];
+    }
+
+    /** Finds the first non-online player in the array. */
+    private int getFirstNotOnlinePlayer(Player<T>[] players) {
+        for (int i = 0; i < players.length; i++) {
+            if (!(players[i] instanceof OnlinePlayer)) {
+                return i;
+            }
+        }
+        throw new RuntimeException("All players are online players");
+    }
+
+    /** Starts processing network events for the local player. */
+    @Override
+    public void start() {
+        isRunning.set(true);
+    }
+
+    /** Stops processing network events. */
+    @Override
+    public void stop() {
+        isRunning.set(false);
+    }
+
+    /**
+     * Called when the server notifies that it is the local player's turn.
+     * Sends the generated move back to the server.
+     */
+    @Override
+    public void onYourTurn(NetworkEvents.YourTurnResponse event) {
+        if (!isRunning.get()) return;
+        int move = mainPlayer.getMove(game.deepCopy());
+        new EventFlow().addPostEvent(NetworkEvents.SendMove.class, event.clientId(), (short) move).postEvent();
+    }
+
+    /**
+     * Handles a move received from the server for any player.
+     * Updates the game state and triggers a UI refresh.
+     */
+    @Override
+    public void onMoveReceived(NetworkEvents.GameMoveResponse event) {
+        if (!isRunning.get()) return;
+        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.
+     */
+    @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

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

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

@@ -0,0 +1,102 @@
+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 final 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
+     */
+    public int getMove(TicTacToeR game) {
+        int depth = 9;
+        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/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/interfaces/IAIMove.java

@@ -1,8 +0,0 @@
-package org.toop.game.interfaces;
-
-import org.toop.game.Game;
-import org.toop.game.records.Move;
-
-public interface IAIMove <T extends Game>{
-    Move findBestMove(T game, int depth);
-}

game/src/main/java/org/toop/game/interfaces/IPlayable.java

@@ -1,9 +0,0 @@
-package org.toop.game.interfaces;
-
-import org.toop.game.enumerators.GameState;
-import org.toop.game.records.Move;
-
-public interface IPlayable {
-    Move[] getLegalMoves();
-    GameState play(Move move);
-}

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

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

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

@@ -0,0 +1,75 @@
+package org.toop.game.players;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AbstractPlayer;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
+
+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<Integer> LastMove;
+
+    public LocalPlayer(String name) {
+        super(name);
+    }
+
+    @Override
+    public int getMove(T gameCopy) {
+        return getValidMove(gameCopy);
+    }
+
+    public void setMove(int move) {
+        LastMove.complete(move);
+    }
+
+    // TODO: helper function, would like to replace to get rid of this method
+    public static boolean contains(int[] array, int value){
+        for (int i : array) if (i == value) return true;
+        return false;
+    }
+
+    private 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;
+    }*/
+}

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

@@ -0,0 +1,26 @@
+package org.toop.game.players;
+
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.player.AbstractPlayer;
+
+/**
+ * Represents a player controlled remotely or over a network.
+ * <p>
+ * This class extends {@link AbstractPlayer} and can be used to implement game logic
+ * where moves are provided by an external source (e.g., another user or a server).
+ * Currently, this class is a placeholder and does not implement move logic.
+ * </p>
+ */
+public class OnlinePlayer<T extends TurnBasedGame<T>> extends AbstractPlayer<T> {
+
+    /**
+     * Constructs a new OnlinePlayer.
+     * <p>
+     * Currently, no additional initialization is performed. Subclasses or
+     * future implementations should provide mechanisms to receive moves from
+     * an external source.
+     */
+    public OnlinePlayer(String name) {
+        super(name);
+    }
+}

game/src/main/java/org/toop/game/records/Move.java

@@ -1,3 +0,0 @@
-package org.toop.game.records;
-
-public record Move(int position, char value) {}