MusicAssetTests

Applied template method pattern to abstract player

.github/workflows/checks.yaml

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

.idea/inspectionProfiles/Project_Default.xml

@@ -4,6 +4,9 @@
     <inspection_tool class="AutoCloseableResource" enabled="true" level="WARNING" enabled_by_default="true">
       <option name="METHOD_MATCHER_CONFIG" value="java.util.Formatter,format,java.io.Writer,append,com.google.common.base.Preconditions,checkNotNull,org.hibernate.Session,close,java.io.PrintWriter,printf,java.io.PrintStream,printf,java.lang.foreign.Arena,ofAuto,java.lang.foreign.Arena,global,org.toop.framework.audio.AudioPlayer,play,java.util.Map,remove,java.util.concurrent.Executors,newSingleThreadScheduledExecutor" />
     </inspection_tool>
+    <inspection_tool class="ThrowablePrintStackTrace" enabled="true" level="WARNING" enabled_by_default="true">
+      <scope name="Tests" level="WARNING" enabled="false" />
+    </inspection_tool>
     <inspection_tool class="WriteOnlyObject" enabled="false" level="WARNING" enabled_by_default="false" />
   </profile>
 </component>

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

@@ -1,40 +1,9 @@
 package org.toop;
 
 import org.toop.app.App;
-import org.toop.framework.audio.*;
-import org.toop.framework.networking.NetworkingClientEventListener;
-import org.toop.framework.networking.NetworkingClientManager;
-import org.toop.framework.resource.ResourceLoader;
-import org.toop.framework.resource.ResourceManager;
-import org.toop.framework.resource.resources.MusicAsset;
-import org.toop.framework.resource.resources.SoundEffectAsset;
 
 public final class Main {
     static void main(String[] args) {
-        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,29 @@
 package org.toop.app;
 
+import javafx.application.Platform;
+import javafx.scene.input.KeyCode;
+import javafx.scene.input.KeyCodeCombination;
+import javafx.scene.input.KeyEvent;
+
+import org.toop.app.widget.Primitive;
 import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.LoadingWidget;
 import org.toop.app.widget.display.SongDisplay;
+import org.toop.app.widget.popup.EscapePopup;
 import org.toop.app.widget.popup.QuitPopup;
 import org.toop.app.widget.view.MainView;
+import org.toop.framework.audio.*;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.eventbus.GlobalEventBus;
+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;
 
@@ -17,6 +33,11 @@ import javafx.scene.Scene;
 import javafx.scene.layout.StackPane;
 import javafx.stage.Stage;
 
+import java.util.Objects;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
 public final class App extends Application {
 	private static Stage stage;
 	private static Scene scene;
@@ -24,65 +45,210 @@ public final class App extends Application {
     private static int height;
     private static int width;
 
-	private static boolean isQuitting;
-
 	public static void run(String[] args) {
 		launch(args);
 	}
 
 	@Override
-	public void start(Stage stage) throws Exception {
+	public void start(Stage stage) {
+		// Start loading localization
+		ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/localization"));
+		ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/style"));
+
         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.setWidth(0);
-		stage.setHeight(720);
+		stage.setHeight(0);
 
 		scene.getRoot();
 
-        stage.setMinWidth(1080);
+        stage.setMinWidth(1200);
-        stage.setMinHeight(720);
+        stage.setMinHeight(800);
 		stage.setOnCloseRequest(event -> {
 			event.consume();
-			startQuit();
+			quit();
 		});
 
 		stage.setScene(scene);
 		stage.setResizable(true);
 
-		stage.show();
-
 		App.stage = stage;
 		App.scene = scene;
 
 		App.width = (int)stage.getWidth();
 		App.height = (int)stage.getHeight();
 
-		App.isQuitting = false;
-
 		AppSettings.applySettings();
-		new EventFlow().addPostEvent(new AudioEvents.StartBackgroundMusic()).asyncPostEvent();
 
-        WidgetContainer.add(Pos.CENTER, new MainView());
+		setKeybinds(root);
-		WidgetContainer.add(Pos.BOTTOM_RIGHT, new SongDisplay());
+
+        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());
+						try {
+							loading.setAmount(e.hasLoadedAmount());
+						} catch (Exception ex) {
+							throw new RuntimeException(ex);
+						}
+                        if (e.hasLoadedAmount() >= e.isLoadingAmount()-1) {
+                            Platform.runLater(loading::triggerSuccess);
+                            loadingFlow.unsubscribe("init_loading");
+                        }
+					});
+
+
+                }, false, "init_loading");
+
+		ExecutorService executor = Executors.newSingleThreadExecutor();
+		try {
+			executor.submit(
+				() -> ResourceManager.loadAssets(new ResourceLoader("app/src/main/resources/assets")
+			));
+		} finally {
+			executor.shutdown();
+		}
+
+		stage.show();
+
 	}
 
-	public static void startQuit() {
+	private void setKeybinds(StackPane root) {
-		if (isQuitting) {
+		root.addEventHandler(KeyEvent.KEY_PRESSED,event -> {
+			if (event.getCode() == KeyCode.ESCAPE) {
+				escapePopup();
+			}
+		});
+        stage.setFullScreenExitKeyCombination(
+                new KeyCodeCombination(
+                        KeyCode.F11
+                )
+        );
+	}
+
+	public void escapePopup() {
+
+		if (   WidgetContainer.getCurrentView() == null
+			|| WidgetContainer.getCurrentView() instanceof MainView) {
 			return;
 		}
 
-		WidgetContainer.add(Pos.CENTER, new QuitPopup());
+		if (!Objects.requireNonNull(
-		isQuitting = true;
+				WidgetContainer.find(widget -> widget instanceof QuitPopup || widget instanceof EscapePopup)
+		).isEmpty()) {
+			WidgetContainer.removeFirst(QuitPopup.class);
+			WidgetContainer.removeFirst(EscapePopup.class);
+			return;
+		}
+
+		EscapePopup escPopup = new EscapePopup();
+		escPopup.show(Pos.CENTER);
 	}
 
-	public static void stopQuit() {
+	private void setOnLoadingSuccess(LoadingWidget loading) {
-		isQuitting = false;
+		loading.setOnSuccess(() -> {
+
+            try {
+                initSystems();
+            } catch (InterruptedException e) {
+                throw new RuntimeException(e);
+            }
+
+            AppSettings.applyMusicVolumeSettings();
+			new EventFlow().addPostEvent(new AudioEvents.StartBackgroundMusic()).postEvent();
+            loading.hide();
+			WidgetContainer.add(Pos.CENTER, new MainView());
+			WidgetContainer.add(Pos.BOTTOM_RIGHT, new SongDisplay());
+			stage.setOnCloseRequest(event -> {
+				event.consume();
+
+				if (WidgetContainer.getAllWidgets().stream().anyMatch(e -> e instanceof QuitPopup)) return;
+
+				QuitPopup a = new QuitPopup();
+				a.show(Pos.CENTER);
+
+			});
+		});
 	}
 
+	private void initSystems() throws InterruptedException { // TODO Move to better place
+
+		final int THREAD_COUNT = 2;
+		CountDownLatch latch = new CountDownLatch(THREAD_COUNT);
+
+		@SuppressWarnings("resource")
+		ExecutorService threads = Executors.newFixedThreadPool(THREAD_COUNT);
+
+		try {
+
+			threads.submit(() -> {
+				new NetworkingClientEventListener(
+						GlobalEventBus.get(),
+						new NetworkingClientManager(GlobalEventBus.get()));
+
+				latch.countDown();
+			});
+
+			threads.submit(() -> {
+				MusicManager<MusicAsset> musicManager =
+						new MusicManager<>(
+								GlobalEventBus.get(),
+								ResourceManager.getAllOfTypeAndRemoveWrapper(MusicAsset.class),
+								true
+						);
+
+				SoundEffectManager<SoundEffectAsset> soundEffectManager =
+						new SoundEffectManager<>(ResourceManager.getAllOfType(SoundEffectAsset.class));
+
+				AudioVolumeManager audioVolumeManager = new AudioVolumeManager()
+						.registerManager(VolumeControl.MASTERVOLUME, musicManager)
+						.registerManager(VolumeControl.MASTERVOLUME, soundEffectManager)
+						.registerManager(VolumeControl.FX, soundEffectManager)
+						.registerManager(VolumeControl.MUSIC, musicManager);
+
+				new AudioEventListener<>(
+						GlobalEventBus.get(),
+						musicManager,
+						soundEffectManager,
+						audioVolumeManager
+				).initListeners("medium-button-click.wav");
+
+				latch.countDown();
+			});
+
+		} finally {
+			latch.await();
+			threads.shutdown();
+		}
+    }
+
 	public static void quit() {
 		stage.close();
 		System.exit(0); // TODO: This is like dropping a nuke

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),
+		REVERSI(2, 10);
-        CONNECT4(2, 7),
-        BATTLESHIP(2, 5);
 
         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 javafx.application.Platform;
-import org.toop.app.game.ReversiGame;
+import javafx.geometry.Pos;
-import org.toop.app.game.TicTacToeGame;
+import org.toop.app.gameControllers.*;
+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.controller.GameController;
+import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.framework.gameFramework.model.player.Player;
 import org.toop.framework.networking.clients.TournamentNetworkingClient;
 import org.toop.framework.networking.events.NetworkEvents;
 import org.toop.framework.networking.types.NetworkingConnector;
+import org.toop.game.games.reversi.BitboardReversi;
+import org.toop.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.game.players.ArtificialPlayer;
+import org.toop.game.players.OnlinePlayer;
+import org.toop.game.players.ai.RandomAI;
 import org.toop.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 GameController gameController;
+
     private final AtomicBoolean isSingleGame = new AtomicBoolean(false);
 
 	private ScheduledExecutorService scheduler;
 
+	private EventFlow connectFlow;
+
 	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,43 +83,104 @@ 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().transitionNextCustom(loading, "disconnect", this::disconnect);
+
+		var a = new EventFlow()
 			.addPostEvent(NetworkEvents.StartClient.class,
-				new TournamentNetworkingClient(),
+				new TournamentNetworkingClient(GlobalEventBus.get()),
-				new NetworkingConnector(ip, parsedPort, 10, 1, TimeUnit.SECONDS)
+				new NetworkingConnector(ip, parsedPort, reconnectAttempts, 1, TimeUnit.SECONDS)
-			)
+			);
-			.onResponse(NetworkEvents.StartClientResponse.class, e -> {
-				this.user = user;
-				clientId = e.clientId();
 
-				new EventFlow().addPostEvent(new NetworkEvents.SendLogin(clientId, user)).postEvent();
+        loading.setOnFailure(() -> {
+            if (WidgetContainer.getCurrentView() == loading) WidgetContainer.getCurrentView().transitionPrevious();
+			a.unsubscribeAll();
+            WidgetContainer.add(
+                    Pos.CENTER,
+                    new ErrorPopup(AppContext.getString("connecting-failed") + " " + ip + ":" + port)
+            );
+        });
 
-				primary = new ServerView(user, this::sendChallenge, this::disconnect);
+		a.onResponse(NetworkEvents.CreatedIdForClient.class, e -> clientId = e.clientId(), true);
-				WidgetContainer.getCurrentView().transitionNext(primary);
 
-				startPopulateScheduler();
+		a.onResponse(NetworkEvents.StartClientResponse.class, e -> {
-				populateGameList();
+			if (!e.successful()) {
+				return;
+			}
 
-			}).postEvent();
+			primary = new ServerView(user, this::sendChallenge);
+			WidgetContainer.getCurrentView().transitionNextCustom(primary, "disconnect", this::disconnect);
 
-		new EventFlow().listen(this::handleReceivedChallenge)
+			a.unsubscribe("connecting");
-                .listen(this::handleMatchResponse);
+			a.unsubscribe("startclient");
+
+			this.user = user;
+
+			new EventFlow().addPostEvent(new NetworkEvents.SendLogin(clientId, user)).postEvent();
+
+			startPopulateScheduler();
+			populateGameList();
+
+			primary.removeViewFromPreviousChain(loading);
+
+		}, false, "startclient")
+				.listen(
+						NetworkEvents.ConnectTry.class,
+						e -> {
+							if (clientId != e.clientId()) return;
+							Platform.runLater(
+									() -> {
+										try {
+											loading.setAmount(e.amount());
+											if (e.amount() >= loading.getMaxAmount()) {
+												loading.triggerFailure();
+											}
+										} catch (Exception ex) {
+											throw new RuntimeException(ex);
+										}
+									}
+							);
+						},
+						false, "connecting"
+				)
+				.postEvent();
+
+		a.listen(NetworkEvents.ChallengeResponse.class, this::handleReceivedChallenge, false, "challenge")
+                .listen(NetworkEvents.GameMatchResponse.class, this::handleMatchResponse, false, "match-response")
+                .listen(NetworkEvents.GameResultResponse.class, this::handleGameResult, false, "game-result")
+                .listen(NetworkEvents.GameMoveResponse.class, this::handleReceivedMove, false, "game-move")
+                .listen(NetworkEvents.YourTurnResponse.class, this::handleYourTurn, false, "your-turn");
+
+		connectFlow = a;
 	}
 
 	private void sendChallenge(String opponent) {
 		if (!isPolling) return;
 
-		new SendChallengePopup(this, opponent, (playerInformation, gameType) -> {
+		var a = new SendChallengePopup(this, opponent, (playerInformation, gameType) -> {
 			new EventFlow().addPostEvent(new NetworkEvents.SendChallenge(clientId, opponent, gameType)).postEvent();
             isSingleGame.set(true);
 		});
+
+		a.show(Pos.CENTER);
 	}
 
     private void handleMatchResponse(NetworkEvents.GameMatchResponse response) {
-        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,32 +201,74 @@ public final class Server {
             information.players[0].computerThinkTime = 1;
             information.players[1].name = response.opponent();
 
-            Runnable onGameOverRunnable = isSingleGame.get()? null: this::gameOver;
+            /*switch (type){
+                case TICTACTOE ->{
+                    players[myTurn] = new ArtificialPlayer<>(new TicTacToeAIR(9), user);
+                }
+                case REVERSI ->{
+                    players[myTurn] = new ArtificialPlayer<>(new ReversiAIR(), user);
+                }
+            }*/
+
 
 
             switch (type) {
-                case TICTACTOE ->
+                case TICTACTOE ->{
-                        new TicTacToeGame(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
+                        Player<BitboardTicTacToe>[] players = new Player[2];
-                case REVERSI ->
+                        players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
-                        new ReversiGame(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
+                        players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), user);
-                case CONNECT4 ->
+                        gameController = new TicTacToeBitController(players);
-                        new Connect4Game(information, myTurn, this::forfeitGame, this::exitGame, this::sendMessage, onGameOverRunnable);
+                }
+                case REVERSI -> {
+                    Player<BitboardReversi>[] players = new Player[2];
+                    players[(myTurn + 1) % 2] = new OnlinePlayer<>(response.opponent());
+                    players[myTurn] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), user);
+                    gameController = new ReversiBitController(players, 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;
 
 		String challengerName = extractQuotedValue(response.challengerName());
 		String gameType = extractQuotedValue(response.gameType());
 		final String finalGameType = gameType;
-		new ChallengePopup(challengerName, gameType, (playerInformation) -> {
+		var a = new ChallengePopup(challengerName, gameType, (playerInformation) -> {
 			final int challengeId = Integer.parseInt(response.challengeId().replaceAll("\\D", ""));
 			new EventFlow().addPostEvent(new NetworkEvents.SendAcceptChallenge(clientId, challengeId)).postEvent();
             isSingleGame.set(true);
 		});
+
+		a.show(Pos.CENTER);
 	}
 
 	private void sendMessage(String message) {
@@ -162,7 +279,9 @@ public final class Server {
 		new EventFlow().addPostEvent(new NetworkEvents.CloseClient(clientId)).postEvent();
 		isPolling = false;
 		stopScheduler();
-		primary.transitionPrevious();
+		connectFlow.unsubscribeAll();
+
+		WidgetContainer.getCurrentView().transitionPrevious();
 	}
 
 	private void forfeitGame() {
@@ -200,7 +319,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/BitGameCanvas.java

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

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

@@ -0,0 +1,5 @@
+package org.toop.app.canvas;
+
+public interface BitLegalMoveDrawer {
+    void showLegalMove(long move, int currentPlayerIndex);
+}

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

@@ -1,11 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-
-import java.util.function.Consumer;
-
-public class Connect4Canvas extends GameCanvas {
-    public Connect4Canvas(Color color, int width, int height, Consumer<Integer> onCellClicked) {
-        super(color, Color.TRANSPARENT, width, height, 7, 6, 10, true, onCellClicked,null);
-    }
-}

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.TurnBasedGame;
+
+public interface DrawPlayerHover {
+    void drawPlayerHover(int player, int move, TurnBasedGame 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

@@ -1,215 +1,8 @@
 package org.toop.app.canvas;
 
-import javafx.animation.KeyFrame;
-import javafx.animation.Timeline;
 import javafx.scene.canvas.Canvas;
-import javafx.scene.canvas.GraphicsContext;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
-import javafx.scene.input.MouseButton;
-import javafx.scene.paint.Color;
-import javafx.util.Duration;
 
-import java.util.concurrent.atomic.AtomicReference;
+public interface GameCanvas<T extends TurnBasedGame<T>> extends GameDrawer<T>{
-import java.util.function.Consumer;
+    Canvas getCanvas();
-
-public abstract class GameCanvas {
-	protected record Cell(float x, float y, float width, float height) {
-		public boolean isInside(double x, double y) {
-			return x >= this.x && x <= this.x + width &&
-				y >= this.y && y <= this.y + height;
-		}
-	}
-
-	protected final Canvas canvas;
-	protected final GraphicsContext graphics;
-
-	protected final Color color;
-	protected final Color backgroundColor;
-
-	protected final int width;
-	protected final int height;
-
-	protected final int rowSize;
-	protected final int columnSize;
-
-	protected final int gapSize;
-	protected final boolean edges;
-
-	protected final Cell[] cells;
-
-	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.color = color;
-		this.backgroundColor = backgroundColor;
-
-		this.width = width;
-		this.height = height;
-
-		this.rowSize = rowSize;
-		this.columnSize = columnSize;
-
-		this.gapSize = gapSize;
-		this.edges = edges;
-
-		cells = new Cell[rowSize * columnSize];
-
-		final float cellWidth = ((float) width - gapSize * rowSize - gapSize) / rowSize;
-		final float cellHeight = ((float) height - gapSize * columnSize - gapSize) / columnSize;
-
-		for (int y = 0; y < columnSize; y++) {
-			final float startY = y * cellHeight + y * gapSize + gapSize;
-
-			for (int x = 0; x < rowSize; x++) {
-				final float startX = x * cellWidth + x * gapSize + gapSize;
-				cells[x + y * rowSize] = new Cell(startX, startY, cellWidth, cellHeight);
-			}
-		}
-
-		canvas.setOnMouseClicked(event -> {
-			if (event.getButton() != MouseButton.PRIMARY) {
-				return;
-			}
-
-			final int column = (int) ((event.getX() / this.width) * rowSize);
-			final int row = (int) ((event.getY() / this.height) * columnSize);
-
-			final Cell cell = cells[column + row * rowSize];
-
-			if (cell.isInside(event.getX(), event.getY())) {
-				event.consume();
-				onCellClicked.accept(column + row * rowSize);
-			}
-		});
-
-
-
-
-		render();
-	}
-
-	private void render() {
-		graphics.setFill(backgroundColor);
-		graphics.fillRect(0, 0, width, height);
-
-		graphics.setFill(color);
-
-		for (int x = 0; x < rowSize - 1; x++) {
-			final float start = cells[x].x + cells[x].width;
-			graphics.fillRect(start, gapSize, gapSize, height - gapSize * 2);
-		}
-
-		for (int y = 0; y < columnSize - 1; y++) {
-			final float start = cells[y * rowSize].y + cells[y * rowSize].height;
-			graphics.fillRect(gapSize, start, width - gapSize * 2, gapSize);
-		}
-
-		if (edges) {
-			graphics.fillRect(0, 0, width, gapSize);
-			graphics.fillRect(0, 0, gapSize, height);
-
-			graphics.fillRect(width - gapSize, 0, gapSize, height);
-			graphics.fillRect(0, height - gapSize, width, gapSize);
-		}
-	}
-
-	public void fill(Color color, int cell) {
-		final float x = cells[cell].x();
-		final float y = cells[cell].y();
-
-		final float width = cells[cell].width();
-		final float height = cells[cell].height();
-
-		graphics.setFill(color);
-		graphics.fillRect(x, y, width, height);
-	}
-
-	public void clear(int cell) {
-		final float x = cells[cell].x();
-		final float y = cells[cell].y();
-
-		final float width = cells[cell].width();
-		final float height = cells[cell].height();
-
-		graphics.clearRect(x, y, width, height);
-
-		graphics.setFill(backgroundColor);
-		graphics.fillRect(x, y, width, height);
-	}
-
-	public void clearAll() {
-		for (int i = 0; i < cells.length; i++) {
-			clear(i);
-		}
-	}
-
-	public void drawDot(Color color, int cell) {
-		final float x = cells[cell].x() + gapSize;
-		final float y = cells[cell].y() + gapSize;
-
-		final float width = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		graphics.setFill(color);
-		graphics.fillOval(x, y, width, height);
-	}
-
-    public void drawInnerDot(Color color, int cell, boolean slightlyBigger) {
-        final float x = cells[cell].x() + gapSize;
-        final float y = cells[cell].y() + gapSize;
-
-        float multiplier = slightlyBigger?1.4f:1.5f;
-
-        final float width = (cells[cell].width() - gapSize * 2)/multiplier;
-        final float height = (cells[cell].height() - gapSize * 2)/multiplier;
-
-        float offset = slightlyBigger?5f:4f;
-
-        graphics.setFill(color);
-        graphics.fillOval(x + width/offset, y + height/offset, width, height);
-    }
-
-	private void drawDotScaled(Color color, int cell, double scale) {
-		final float cx = cells[cell].x() + gapSize;
-		final float cy = cells[cell].y() + gapSize;
-
-		final float fullWidth = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		final float scaledWidth = (float)(fullWidth * scale);
-		final float offsetX = (fullWidth - scaledWidth) / 2;
-
-		graphics.setFill(color);
-		graphics.fillOval(cx + offsetX, cy, scaledWidth, height);
-	}
-
-	public Timeline flipDot(Color fromColor, Color toColor, int cell) {
-		final int steps = 60;
-		final long duration = 250;
-		final double interval = duration / (double) steps;
-
-		final Timeline timeline = new Timeline();
-
-		for (int i = 0; i <= steps; i++) {
-			final double t = i / (double) steps;
-			final KeyFrame keyFrame = new KeyFrame(Duration.millis(i * interval),
-				_ -> {
-					clear(cell);
-
-					final double scale = t <= 0.5 ? 1 - 2 * t : 2 * t - 1;
-					final Color currentColor = t < 0.5 ? fromColor : toColor;
-
-					drawDotScaled(currentColor, cell, scale);
-				}
-			);
-
-			timeline.getKeyFrames().add(keyFrame);
-		}
-
-		return timeline;
-	}
-
-	public Canvas getCanvas() {
-		return canvas;
-	}
 }

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

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

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

@@ -0,0 +1,77 @@
+package org.toop.app.canvas;
+
+import javafx.scene.paint.Color;
+import org.toop.app.App;
+import org.toop.game.games.reversi.BitboardReversi;
+
+public class ReversiBitCanvas extends BitGameCanvas<BitboardReversi> implements BitLegalMoveDrawer {
+
+    private final boolean switchColors;
+    private final boolean local;
+
+    public ReversiBitCanvas(boolean switchColors, boolean local) {
+        super(Color.GRAY, new Color(0f, 0.4f, 0.2f, 1f), (App.getHeight() / 4) * 3, (App.getHeight() / 4) * 3, 8, 8, 5, true);
+        this.switchColors = switchColors;
+        this.local = local;
+        canvas.setOnMouseMoved(event -> {
+            double mouseX = event.getX();
+            double mouseY = event.getY();
+            int cellId = -1;
+
+            BitGameCanvas.Cell hovered = null;
+            for (BitGameCanvas.Cell cell : cells) {
+                if (cell.isInside(mouseX, mouseY)) {
+                    hovered = cell;
+                    cellId = turnCoordsIntoCellId(mouseX, mouseY);
+                    break;
+                }
+            }
+        });
+    }
+
+    private int turnCoordsIntoCellId(double x, double y) {
+        final int column = (int) ((x / this.width) * rowSize);
+        final int row = (int) ((y / this.height) * columnSize);
+        return column + row * rowSize;
+    }
+
+    @Override
+    public void redraw(BitboardReversi gameCopy) {
+        clearAll();
+        long[] board = gameCopy.getBoard();
+        if (switchColors && local) {
+            loopOverBoard(board[0], (i) -> drawDot(Color.BLACK, i));
+            loopOverBoard(board[1], (i) -> drawDot(Color.WHITE, i));
+        } else {
+            loopOverBoard(board[0], (i) -> drawDot(Color.WHITE, i));
+            loopOverBoard(board[1], (i) -> drawDot(Color.BLACK, i));
+        }
+    }
+
+    @Override
+    public void showLegalMove(long move, int currentPlayerIndex) {
+        int idx = Long.numberOfTrailingZeros(move);
+        drawLegalMove(idx, currentPlayerIndex);
+    }
+
+    public void drawLegalMove(int cell, int player) {
+        Color innerColor;
+        if (switchColors) {
+            if (player == 0) {
+                innerColor = new Color(0.0f, 0.0f, 0.0f, 0.6f);
+            }
+            else {
+                innerColor = new Color(1.0f, 1.0f, 1.0f, 0.75f);
+            }
+            this.drawInnerDot(innerColor, cell, false);
+        } else {
+        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);
+        }
+        this.drawInnerDot(innerColor, cell, false);
+        }
+    }
+}

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

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

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

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

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

@@ -1,38 +0,0 @@
-package org.toop.app.canvas;
-
-import javafx.scene.paint.Color;
-
-import java.util.function.Consumer;
-
-public final class TicTacToeCanvas extends GameCanvas {
-	public TicTacToeCanvas(Color color, int width, int height, Consumer<Integer> onCellClicked) {
-		super(color, Color.TRANSPARENT, width, height, 3, 3, 30, false, onCellClicked,null);
-	}
-
-	public void drawX(Color color, int cell) {
-		graphics.setStroke(color);
-		graphics.setLineWidth(gapSize);
-
-		final float x = cells[cell].x() + gapSize;
-		final float y = cells[cell].y() + gapSize;
-
-		final float width = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		graphics.strokeLine(x, y, x + width, y + height);
-		graphics.strokeLine(x + width, y, x, y + height);
-	}
-
-	public void drawO(Color color, int cell) {
-		graphics.setStroke(color);
-		graphics.setLineWidth(gapSize);
-
-		final float x = cells[cell].x() + gapSize;
-		final float y = cells[cell].y() + gapSize;
-
-		final float width = cells[cell].width() - gapSize * 2;
-		final float height = cells[cell].height() - gapSize * 2;
-
-		graphics.strokeOval(x, y, width, height);
-	}
-}

app/src/main/java/org/toop/app/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/GenericGameController.java

@@ -0,0 +1,161 @@
+package org.toop.app.gameControllers;
+
+import javafx.application.Platform;
+import javafx.geometry.Pos;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.app.canvas.GameCanvas;
+import org.toop.app.canvas.BitLegalMoveDrawer;
+import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.view.GameView;
+import org.toop.framework.eventbus.EventFlow;
+import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.framework.gameFramework.controller.GameController;
+import org.toop.framework.gameFramework.model.game.SupportsOnlinePlay;
+import org.toop.framework.gameFramework.model.game.TurnBasedGame;
+import org.toop.framework.gameFramework.model.game.threadBehaviour.ThreadBehaviour;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.framework.gameFramework.view.GUIEvents;
+import org.toop.framework.networking.events.NetworkEvents;
+import org.toop.game.players.LocalPlayer;
+
+public class GenericGameController<T extends TurnBasedGame<T>, C extends GameCanvas<T>> implements GameController {
+    protected final EventFlow eventFlow = new EventFlow();
+
+    // Logger for logging
+    protected final Logger logger = LogManager.getLogger(this.getClass());
+
+    // Reference to gameView view
+    protected final GameView gameView;
+
+    // Reference to String gametype
+    protected final String gameType;
+
+    // Reference to game canvas
+    protected final C canvas;
+
+    protected final TurnBasedGame<T> game;       // Reference to game instance
+    private final ThreadBehaviour gameThreadBehaviour;
+
+    // TODO: Change gameType to automatically happen with either dependency injection or something else.
+    public GenericGameController(C canvas, T game, ThreadBehaviour gameThreadBehaviour, String gameType) {
+        logger.info("Creating: " + this.getClass());
+
+        this.canvas = canvas;
+        this.game = game;
+        this.gameType = gameType;
+        this.gameThreadBehaviour = gameThreadBehaviour;
+
+        // Tell thread how to send moves
+        this.gameThreadBehaviour.setOnSendMove((id, m) -> GlobalEventBus.get().post(new NetworkEvents.SendMove(id, (short)translateMove(m))));
+
+        // Tell thread how to update UI
+        this.gameThreadBehaviour.setOnUpdateUI(() -> Platform.runLater(this::updateUI));
+
+        // Change scene to game view
+        gameView = new GameView(null, null, null, gameType);
+        gameView.add(Pos.CENTER, canvas.getCanvas());
+        WidgetContainer.getCurrentView().transitionNext(gameView, true);
+
+        // Listen to updates
+        eventFlow
+                .listen(GUIEvents.GameEnded.class, this::onGameFinish, false)
+                .listen(GUIEvents.PlayerAttemptedMove.class, event -> {if (getCurrentPlayer() instanceof LocalPlayer<T> lp){lp.setLastMove(event.move());}}, false);
+    }
+
+    public void start(){
+        logger.info("Starting GameManager");
+        updateUI();
+        gameThreadBehaviour.start();
+    }
+
+    public void stop(){
+        logger.info("Stopping GameManager");
+        removeListeners();
+        gameThreadBehaviour.stop();
+    }
+
+    public Player<T> getCurrentPlayer(){
+        return game.getPlayer(getCurrentPlayerIndex());
+    }
+
+    public int getCurrentPlayerIndex(){
+        return game.getCurrentTurn();
+    }
+
+    protected long translateMove(int move){
+        return 1L << move;
+    }
+
+    protected int translateMove(long move){
+        return Long.numberOfTrailingZeros(move);
+    }
+
+    private void removeListeners(){
+        eventFlow.unsubscribeAll();
+    }
+
+    private void onGameFinish(GUIEvents.GameEnded event){
+        logger.info("Game Finished");
+        String name = event.winner() == -1 ? null : getPlayer(event.winner()).getName();
+        gameView.gameOver(event.winOrTie(), name);
+        stop();
+    }
+
+    public Player<T> getPlayer(int player){
+        if (player < 0 || player >= 2){ // TODO: Make game turn player count
+            logger.error("Invalid player index");
+            throw new IllegalArgumentException("player out of range");
+        }
+        return game.getPlayer(player);
+    }
+
+    private boolean isOnline(){
+        return this.gameThreadBehaviour instanceof SupportsOnlinePlay;
+    }
+
+    public void onYourTurn(NetworkEvents.YourTurnResponse event){
+        if (isOnline()){
+            ((SupportsOnlinePlay) this.gameThreadBehaviour).onYourTurn(event.clientId());
+        }
+    }
+
+    public void onMoveReceived(NetworkEvents.GameMoveResponse event){
+        if (isOnline()){
+            ((SupportsOnlinePlay) this.gameThreadBehaviour).onMoveReceived(
+                    translateMove(Integer.parseInt(event.move())));
+        }
+    }
+
+    public void gameFinished(NetworkEvents.GameResultResponse event){
+        if (isOnline()){
+            ((SupportsOnlinePlay) this.gameThreadBehaviour).gameFinished(event.condition());
+        }
+    }
+
+    @Override
+    public void sendMove(long clientId, long move) {
+        new EventFlow().addPostEvent(NetworkEvents.SendMove.class, clientId, (short) Long.numberOfTrailingZeros(move)).asyncPostEvent();
+    }
+
+    @Override
+    public void updateUI() {
+        canvas.redraw(game.deepCopy());
+        gameView.updatePlayerInfo(
+               true,
+               getCurrentPlayer().getName(),
+               game.getCurrentTurn() == 0 ? "X" : "O",
+               getPlayer((game.getCurrentTurn() + 1 ) % 2).getName(),
+               this.gameType
+       );
+        // draw legal moves for bit canvasses
+        if (canvas instanceof BitLegalMoveDrawer) {
+            long movesLoop = game.getLegalMoves();
+            while (movesLoop != 0) {
+                long move = 1L << Long.numberOfTrailingZeros(movesLoop);
+                ((BitLegalMoveDrawer) canvas).showLegalMove(move, getCurrentPlayerIndex());
+                movesLoop &= movesLoop - 1;
+            }
+        }
+    }
+}

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

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

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

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

app/src/main/java/org/toop/app/view/View.java

@@ -1,400 +0,0 @@
-package org.toop.app.view;
-
-import org.toop.framework.audio.events.AudioEvents;
-import org.toop.framework.eventbus.EventFlow;
-
-import javafx.geometry.Pos;
-import javafx.scene.Node;
-import javafx.scene.control.Button;
-import javafx.scene.control.ComboBox;
-import javafx.scene.control.ScrollPane;
-import javafx.scene.control.Separator;
-import javafx.scene.control.Slider;
-import javafx.scene.control.TextField;
-import javafx.scene.layout.HBox;
-import javafx.scene.layout.Region;
-import javafx.scene.layout.StackPane;
-import javafx.scene.layout.VBox;
-import javafx.scene.text.Text;
-
-import java.util.HashMap;
-import java.util.Map;
-
-public abstract class View {
-	private final boolean mainView;
-
-	private final StackPane view;
-	private final Map<String, Node> nodeMap;
-
-	protected View(boolean mainView, String cssClass) {
-		this.mainView = mainView;
-
-		view = new StackPane();
-		view.getStyleClass().add(cssClass);
-
-		nodeMap = new HashMap<String, Node>();
-	}
-
-	public void add(Pos position, Node node) {
-		assert node != null;
-
-		StackPane.setAlignment(node, position);
-		view.getChildren().add(node);
-	}
-
-	protected Region hspacer() {
-		final Region hspacer = new Region();
-		hspacer.getStyleClass().add("hspacer");
-
-		return hspacer;
-	}
-
-	protected Region vspacer() {
-		final Region vspacer = new Region();
-		vspacer.getStyleClass().add("vspacer");
-
-		return vspacer;
-	}
-
-	protected ScrollPane fit(String identifier, String cssClass, Node node) {
-		assert node != null;
-
-		final ScrollPane fit = new ScrollPane(node);
-		fit.getStyleClass().add(cssClass);
-
-		fit.setMaxSize(Region.USE_PREF_SIZE, Region.USE_PREF_SIZE);
-		fit.setFitToWidth(true);
-		fit.setFitToHeight(true);
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, fit);
-		}
-
-		return fit;
-	}
-
-	protected ScrollPane fit(String identifier, Node node) {
-		return fit(identifier, "fit", node);
-	}
-
-	protected ScrollPane fit(Node node) {
-		return fit("", node);
-	}
-
-	protected HBox hbox(String identifier, String cssClass, Node... nodes) {
-		assert !nodeMap.containsKey(identifier);
-
-		final HBox hbox = new HBox();
-		hbox.getStyleClass().add(cssClass);
-		hbox.setMaxSize(Region.USE_PREF_SIZE, Region.USE_PREF_SIZE);
-
-		for (final Node node : nodes) {
-			if (node != null) {
-				hbox.getChildren().add(node);
-			}
-		}
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, hbox);
-		}
-
-		return hbox;
-	}
-
-	protected HBox hbox(String identifier, Node... nodes) {
-		return hbox(identifier, "container", nodes);
-	}
-
-	protected HBox hbox(Node... nodes) {
-		return hbox("", nodes);
-	}
-
-	protected HBox hboxFill(String identifier, String cssClass, Node... nodes) {
-		final HBox hbox = hbox(identifier, cssClass, nodes);
-
-		for (final Node node : hbox.getChildren()) {
-			if (node instanceof Region) {
-				((Region)node).setMaxHeight(Double.MAX_VALUE);
-			}
-		}
-
-		return hbox;
-	}
-
-	protected HBox hboxFill(String identifier, Node... nodes) {
-		final HBox hbox = hbox(identifier, nodes);
-
-		for (final Node node : hbox.getChildren()) {
-			if (node instanceof Region) {
-				((Region)node).setMaxHeight(Double.MAX_VALUE);
-			}
-		}
-
-		return hbox;
-	}
-
-	protected HBox hboxFill(Node... nodes) {
-		final HBox hbox = hbox(nodes);
-
-		for (final Node node : hbox.getChildren()) {
-			if (node instanceof Region) {
-				((Region)node).setMaxHeight(Double.MAX_VALUE);
-			}
-		}
-
-		return hbox;
-	}
-
-	protected VBox vbox(String identifier, String cssClass, Node... nodes) {
-		assert !nodeMap.containsKey(identifier);
-
-		final VBox vbox = new VBox();
-		vbox.getStyleClass().add(cssClass);
-		vbox.setMaxSize(Region.USE_PREF_SIZE, Region.USE_PREF_SIZE);
-
-		for (final Node node : nodes) {
-			if (node != null) {
-				vbox.getChildren().add(node);
-			}
-		}
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, vbox);
-		}
-
-		return vbox;
-	}
-
-	protected VBox vbox(String identifier, Node... nodes) {
-		return vbox(identifier, "container", nodes);
-	}
-
-	protected VBox vbox(Node... nodes) {
-		return vbox("", nodes);
-	}
-
-	protected VBox vboxFill(String identifier, String cssClass, Node... nodes) {
-		final VBox vbox = vbox(identifier, cssClass, nodes);
-
-		for (final Node node : vbox.getChildren()) {
-			if (node instanceof Region) {
-				((Region)node).setMaxWidth(Double.MAX_VALUE);
-			}
-		}
-
-		return vbox;
-	}
-
-	protected VBox vboxFill(String identifier, Node... nodes) {
-		final VBox vbox = vbox(identifier, nodes);
-
-		for (final Node node : vbox.getChildren()) {
-			if (node instanceof Region) {
-				((Region)node).setMaxWidth(Double.MAX_VALUE);
-			}
-		}
-
-		return vbox;
-	}
-
-	protected VBox vboxFill(Node... nodes) {
-		final VBox vbox = vbox(nodes);
-
-		for (final Node node : vbox.getChildren()) {
-			if (node instanceof Region) {
-				((Region)node).setMaxWidth(Double.MAX_VALUE);
-			}
-		}
-
-		return vbox;
-	}
-
-	protected Separator separator(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final Separator separator = new Separator();
-		separator.getStyleClass().add(cssClass);
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, separator);
-		}
-
-		return separator;
-	}
-
-	protected Separator separator(String identifier) {
-		return separator(identifier, "separator");
-	}
-
-	protected Separator separator() {
-		return separator("");
-	}
-
-	protected Text header(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final Text header = new Text();
-		header.getStyleClass().add(cssClass);
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, header);
-		}
-
-		return header;
-	}
-
-	protected Text header(String identifier) {
-		return header(identifier, "header");
-	}
-
-	protected Text header() {
-		return header("");
-	}
-
-	protected Text text(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final Text text = new Text();
-		text.getStyleClass().add(cssClass);
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, text);
-		}
-
-		return text;
-	}
-
-	protected Text text(String identifier) {
-		return text(identifier, "text");
-	}
-
-	protected Text text() {
-		return text("");
-	}
-
-	protected Button button(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final Button button = new Button();
-		button.getStyleClass().add(cssClass);
-
-		button.setOnMouseClicked(_ -> {
-			new EventFlow().addPostEvent(new AudioEvents.ClickButton()).asyncPostEvent();
-		});
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, button);
-		}
-
-		return button;
-	}
-
-	protected Button button(String identifier) {
-		return button(identifier, "button");
-	}
-
-	protected Button button() {
-		return button("");
-	}
-
-	protected Slider slider(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final Slider slider = new Slider();
-		slider.getStyleClass().add(cssClass);
-
-		slider.setMinorTickCount(0);
-		slider.setMajorTickUnit(1);
-		slider.setBlockIncrement(1);
-
-		slider.setSnapToTicks(true);
-		slider.setShowTickLabels(true);
-
-		slider.setOnMouseClicked(_ -> {
-			new EventFlow().addPostEvent(new AudioEvents.ClickButton()).asyncPostEvent();
-		});
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, slider);
-		}
-
-		return slider;
-	}
-
-	protected Slider slider(String identifier) {
-		return slider(identifier, "slider");
-	}
-
-	protected Slider slider() {
-		return slider("");
-	}
-
-	protected TextField input(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final TextField input = new TextField();
-		input.getStyleClass().add(cssClass);
-
-		input.setOnMouseClicked(_ -> {
-			new EventFlow().addPostEvent(new AudioEvents.ClickButton()).asyncPostEvent();
-		});
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, input);
-		}
-
-		return input;
-	}
-
-	protected TextField input(String identifier) {
-		return input(identifier, "input");
-	}
-
-	protected TextField input() {
-		return input("");
-	}
-
-	protected <T> ComboBox<T> combobox(String identifier, String cssClass) {
-		assert !nodeMap.containsKey(identifier);
-
-		final ComboBox<T> combobox = new ComboBox<T>();
-		combobox.getStyleClass().add(cssClass);
-
-		combobox.setOnMouseClicked(_ -> {
-			new EventFlow().addPostEvent(new AudioEvents.ClickButton()).asyncPostEvent();
-		});
-
-		if (!identifier.isEmpty()) {
-			nodeMap.put(identifier, combobox);
-		}
-
-		return combobox;
-	}
-
-	protected <T> ComboBox<T> combobox(String identifier) {
-		return combobox(identifier, "combo-box");
-	}
-
-	protected <T> ComboBox<T> combobox() {
-		return combobox("");
-	}
-
-	@SuppressWarnings("unchecked")
-	protected <T extends Node> T get(String identifier) {
-		assert nodeMap.containsKey(identifier);
-		return (T) nodeMap.get(identifier);
-	}
-
-	protected void clear() {
-		view.getChildren().clear();
-		nodeMap.clear();
-	}
-
-	public boolean isMainView() { return mainView; }
-	public Region getView() { return view; }
-
-	public abstract void setup();
-	public void cleanup() {
-		clear();
-	}
-}

app/src/main/java/org/toop/app/view/ViewStack.java

@@ -1,105 +0,0 @@
-package org.toop.app.view;
-
-import javafx.application.Platform;
-import javafx.scene.Scene;
-import javafx.scene.layout.StackPane;
-
-import java.util.Stack;
-
-public final class ViewStack {
-	private static boolean setup = false;
-
-	private static StackPane root;
-
-	private static View active;
-	private static Stack<View> stack;
-
-	public static void setup(Scene scene) {
-		assert scene != null;
-
-		if (setup) {
-			return;
-		}
-
-		root = new StackPane();
-
-		active = null;
-		stack = new Stack<View>();
-
-		scene.setRoot(root);
-
-		setup = true;
-	}
-
-	public static void cleanup() {
-		assert setup;
-
-		final var count = stack.size();
-
-		for (int i = 0; i < count; i++) {
-			pop();
-		}
-
-		if (active != null) {
-			active.cleanup();
-		}
-
-		setup = false;
-	}
-
-	public static void reload() {
-		assert setup;
-
-		for (final var view : stack) {
-			view.cleanup();
-		}
-
-		if (active != null) {
-			active.cleanup();
-			active.setup();
-		}
-
-		for (final var view : stack) {
-			view.setup();
-		}
-	}
-
-	public static void push(View view) {
-		assert setup;
-		assert view != null;
-
-		if (view.isMainView()) {
-			Platform.runLater(() -> {
-				if (active != null) {
-					root.getChildren().removeFirst();
-					active.cleanup();
-				}
-
-				root.getChildren().addFirst(view.getView());
-				view.setup();
-
-				active = view;
-			});
-		} else {
-			Platform.runLater(() -> {
-				stack.push(view);
-				root.getChildren().addLast(view.getView());
-				view.setup();
-			});
-		}
-	}
-
-	public static void pop() {
-		assert setup;
-
-		if (stack.isEmpty()) {
-			return;
-		}
-
-		Platform.runLater(() -> {
-			final var last = stack.pop();
-			root.getChildren().removeLast();
-			last.cleanup();
-		});
-	}
-}

app/src/main/java/org/toop/app/view/displays/SongDisplay.java

@@ -1,128 +0,0 @@
-package org.toop.app.view.displays;
-
-import javafx.application.Platform;
-import javafx.scene.Node;
-import javafx.scene.control.Button;
-import javafx.scene.control.ProgressBar;
-import javafx.scene.layout.HBox;
-import javafx.scene.layout.VBox;
-import javafx.scene.paint.Color;
-import org.toop.app.widget.Widget;
-import org.toop.framework.audio.AudioEventListener;
-import org.toop.framework.audio.events.AudioEvents;
-import org.toop.framework.eventbus.EventFlow;
-import javafx.geometry.Pos;
-import javafx.scene.text.Text;
-import org.toop.framework.eventbus.GlobalEventBus;
-
-public class SongDisplay extends VBox implements Widget {
-
-    private final Text songTitle;
-    private final ProgressBar progressBar;
-    private final Text progressText;
-    private boolean paused = false;
-
-    public SongDisplay() {
-        new EventFlow()
-                .listen(this::updateTheSong);
-
-        setAlignment(Pos.CENTER);
-        getStyleClass().add("song-display");
-
-        songTitle = new Text("song playing");
-        songTitle.getStyleClass().add("song-title");
-
-        progressBar = new ProgressBar(0);
-        progressBar.getStyleClass().add("progress-bar");
-
-        progressText = new Text("0:00/0:00");
-        progressText.getStyleClass().add("progress-text");
-
-        Button skipButton = new Button(">>");
-        Button pauseButton = new Button("⏸");
-        Button previousButton = new Button("<<");
-
-        skipButton.getStyleClass().setAll("skip-button");
-        pauseButton.getStyleClass().setAll("pause-button");
-        previousButton.getStyleClass().setAll("previous-button");
-
-        skipButton.setOnAction( event -> {
-            GlobalEventBus.post(new AudioEvents.SkipMusic());
-            paused = false;
-            pauseButton.setText(getPlayString(paused));
-        });
-
-        pauseButton.setOnAction(event -> {
-            GlobalEventBus.post(new AudioEvents.PauseMusic());
-            paused = !paused;
-            pauseButton.setText(getPlayString(paused));
-        });
-
-        previousButton.setOnAction( event -> {
-            GlobalEventBus.post(new AudioEvents.PreviousMusic());
-            paused = false;
-            pauseButton.setText(getPlayString(paused));
-        });
-
-        HBox control = new HBox(10, previousButton, pauseButton, skipButton);
-        control.setAlignment(Pos.CENTER);
-        control.getStyleClass().add("controls");
-
-        getChildren().addAll(songTitle, progressBar, progressText, control);
-    }
-
-    private void updateTheSong(AudioEvents.PlayingMusic event) {
-        Platform.runLater(() -> {
-            String text = event.name();
-            text = text.substring(0, text.length() - 4);
-            songTitle.setText(text);
-            double currentPos = event.currentPosition();
-            double duration = event.duration();
-            if (currentPos / duration > 0.05) {
-                double progress = currentPos / duration;
-                progressBar.setProgress(progress);
-            }
-            else if (currentPos / duration < 0.05) {
-                progressBar.setProgress(0.05);
-            }
-            progressText.setText(getTimeString(event.currentPosition(), event.duration()));
-        });
-    }
-
-    private String getTimeString(long position, long duration) {
-        long positionMinutes = position / 60;
-        long durationMinutes = duration / 60;
-        long positionSeconds = position % 60;
-        long durationSeconds = duration % 60;
-        String positionSecondsStr = String.valueOf(positionSeconds);
-        String durationSecondsStr = String.valueOf(durationSeconds);
-
-        if (positionSeconds < 10) {
-            positionSecondsStr  = "0" + positionSeconds;
-        }
-        if (durationSeconds < 10) {
-            durationSecondsStr = "0" + durationSeconds;
-        }
-
-        String time = positionMinutes + ":" + positionSecondsStr + " / " + durationMinutes + ":" + durationSecondsStr;
-        return time;
-    }
-
-	@Override
-	public Node getNode() {
-		return this;
-	}
-    private String getPlayString(boolean paused) {
-        if (paused) {
-            return "▶";
-        }
-        else {
-            return "⏸";
-        }
-    }
-}
-
-
-
-
-

app/src/main/java/org/toop/app/view/views/ChallengeView.java

@@ -1,127 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.GameInformation;
-import org.toop.app.Server;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.Node;
-import javafx.scene.control.Button;
-import javafx.scene.control.Slider;
-import javafx.scene.text.Text;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.Consumer;
-
-public final class ChallengeView extends View {
-	private final GameInformation.Player playerInformation;
-
-	private final String challenger;
-	private final String game;
-
-	private final Consumer<GameInformation.Player> onAccept;
-
-	public ChallengeView(String challenger, String game, Consumer<GameInformation.Player> onAccept) {
-		super(false, "bg-popup");
-
-		playerInformation = new GameInformation.Player();
-
-		this.challenger = challenger;
-		this.game = game;
-
-		this.onAccept = onAccept;
-	}
-
-	@Override
-	public void setup() {
-		final Text challengeText = text();
-		challengeText.setText(AppContext.getString("you-were-challenged-by"));
-
-		final Text challengerHeader = header();
-		challengerHeader.setText(challenger);
-
-		final Text gameText = text();
-		gameText.setText(AppContext.getString("to-a-game-of") + " " + game);
-
-		final Button acceptButton = button();
-		acceptButton.setText(AppContext.getString("accept"));
-		acceptButton.setOnAction(_ -> {
-			onAccept.accept(playerInformation);
-		});
-
-		final Button denyButton = button();
-		denyButton.setText(AppContext.getString("deny"));
-		denyButton.setOnAction(_ -> {
-            ViewStack.pop();
-		});
-
-		final List<Node> nodes = new ArrayList<>();
-
-		if (playerInformation.isHuman) {
-			final Button playerToggle = button();
-			playerToggle.setText(AppContext.getString("player"));
-			playerToggle.setOnAction(_ -> {
-				playerInformation.isHuman = false;
-				cleanup();
-				setup();
-			});
-
-			nodes.add(vbox(playerToggle));
-		} else {
-			final Button computerToggle = button();
-			computerToggle.setText(AppContext.getString("computer"));
-			computerToggle.setOnAction(_ -> {
-				playerInformation.isHuman = true;
-				cleanup();
-				setup();
-			});
-
-			nodes.add(vbox(computerToggle));
-
-			final Text computerDifficultyText = text();
-			computerDifficultyText.setText(AppContext.getString("computer-difficulty"));
-
-			final Slider computerDifficultySlider = slider();
-			computerDifficultySlider.setMin(0);
-			computerDifficultySlider.setMax(Server.gameToType(game).getMaxDepth());
-			computerDifficultySlider.setValue(playerInformation.computerDifficulty);
-			computerDifficultySlider.valueProperty().addListener((_, _, newValue) -> {
-				playerInformation.computerDifficulty = newValue.intValue();
-			});
-
-			nodes.add(vbox(computerDifficultyText, computerDifficultySlider));
-		}
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.CENTER,
-			fit(hboxFill(
-				vboxFill(
-					challengeText,
-					challengerHeader,
-					gameText,
-					separator(),
-
-					hboxFill(
-						acceptButton,
-						denyButton
-					)
-				),
-
-				vboxFill(
-					nodes.toArray(new Node[0])
-				)
-			))
-		);
-	}
-}

app/src/main/java/org/toop/app/view/views/CreditsView.java

@@ -1,110 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.App;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.local.AppContext;
-
-import javafx.animation.KeyFrame;
-import javafx.animation.KeyValue;
-import javafx.animation.Timeline;
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.control.ScrollPane;
-import javafx.scene.layout.VBox;
-import javafx.scene.text.Text;
-import javafx.util.Duration;
-
-public final class CreditsView extends View {
-	public CreditsView() {
-		super(false, "bg-primary");
-	}
-
-	@Override
-	public void setup() {
-		final Text scrumMasterHeader = header();
-		scrumMasterHeader.setText(AppContext.getString("scrum-master") + ": Stef");
-
-		final Text productOwnerHeader = header();
-		productOwnerHeader.setText(AppContext.getString("product-owner") + ": Omar");
-
-		final Text mergeCommanderHeader = header();
-		mergeCommanderHeader.setText(AppContext.getString("merge-commander") + ": Bas");
-
-		final Text localizationHeader = header();
-		localizationHeader.setText(AppContext.getString("localization") + ": Ticho");
-
-		final Text aiHeader = header();
-		aiHeader.setText(AppContext.getString("ai") + ": Michiel");
-
-		final Text developersHeader = header();
-		developersHeader.setText(AppContext.getString("developers") + ": Michiel, Bas, Stef, Omar, Ticho");
-
-		final Text moralSupportHeader = header();
-		moralSupportHeader.setText(AppContext.getString("moral-support") + ": Wesley");
-
-		final Text openglHeader = header();
-		openglHeader.setText(AppContext.getString("opengl") + ": Omar");
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.CENTER,
-			fit("credits-fit", vboxFill("credits-container", "credits-container",
-				vbox("credits-spacer-top", ""),
-
-				scrumMasterHeader,
-				productOwnerHeader,
-				mergeCommanderHeader,
-				localizationHeader,
-				aiHeader,
-				developersHeader,
-				moralSupportHeader,
-				openglHeader,
-
-				vbox("credits-spacer-bottom", "")
-			))
-		);
-
-		final Button backButton = button();
-		backButton.setText(AppContext.getString("back"));
-		backButton.setOnAction(_ -> { ViewStack.pop(); });
-
-		add(Pos.BOTTOM_LEFT,
-			vboxFill(
-				backButton
-			)
-		);
-
-		playCredits(100, 20);
-	}
-
-	private void playCredits(int lineHeight, int length) {
-		final ScrollPane creditsFit = get("credits-fit");
-		creditsFit.setVbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);
-		creditsFit.setHbarPolicy(ScrollPane.ScrollBarPolicy.NEVER);
-
-		final VBox creditsContainer = get("credits-container");
-		creditsContainer.setSpacing(lineHeight);
-
-		final VBox creditsSpacerTop = get("credits-spacer-top");
-		creditsSpacerTop.setMinHeight(App.getHeight() - lineHeight);
-
-		final VBox creditsSpacerBottom = get("credits-spacer-bottom");
-		creditsSpacerBottom.setMinHeight(App.getHeight() - lineHeight);
-
-		final Timeline timeline = new Timeline(
-			new KeyFrame(Duration.seconds(0), new KeyValue(creditsFit.vvalueProperty(), 0.0)),
-			new KeyFrame(Duration.seconds(length), new KeyValue(creditsFit.vvalueProperty(), 1.0))
-		);
-
-		timeline.setCycleCount(Timeline.INDEFINITE);
-		timeline.play();
-	}
-}

app/src/main/java/org/toop/app/view/views/ErrorView.java

@@ -1,45 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.text.Text;
-
-public final class ErrorView extends View {
-	private final String error;
-
-	public ErrorView(String error) {
-		super(false, "bg-popup");
-		this.error = error;
-	}
-
-	@Override
-	public void setup() {
-		final Text errorHeader = header();
-		errorHeader.setText(AppContext.getString("error"));
-
-		final Text errorText = text();
-		errorText.setText(error);
-
-		final Button okButton = button();
-		okButton.setText(AppContext.getString("ok"));
-		okButton.setOnAction(_ -> { ViewStack.pop(); });
-
-		add(Pos.CENTER,
-			vboxFill(
-				errorHeader,
-				separator(),
-
-				vspacer(),
-				errorText,
-				vspacer(),
-
-				separator(),
-				okButton
-			)
-		);
-	}
-}

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

@@ -1,179 +0,0 @@
-package org.toop.app.view.views;
-
-import javafx.application.Platform;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.control.ListView;
-import javafx.scene.control.TextField;
-import javafx.scene.text.Text;
-
-import java.util.function.Consumer;
-
-public final class GameView extends View {
-    // TODO: This should be it's own file...
-	private static class GameOverView extends View {
-		private final boolean iWon;
-		private final String winner;
-
-        // TODO: Make winner generic, there is no "I won" unless you play online or against bot. Should be a generic "... won" to simplify
-		public GameOverView(boolean iWon, String winner) {
-			super(false, "bg-popup");
-
-			this.iWon = iWon;
-			this.winner = winner;
-		}
-
-		@Override
-		public void setup() {
-			final Text gameOverHeader = header();
-			gameOverHeader.setText(AppContext.getString("game-over"));
-
-			final Button okButton = button();
-			okButton.setText(AppContext.getString("ok"));
-			okButton.setOnAction(_ -> { ViewStack.pop(); });
-
-			Text gameOverText = text();
-
-			if (winner.isEmpty()) {
-				gameOverText.setText(AppContext.getString("the-game-ended-in-a-draw"));
-			} else {
-				if (iWon) {
-					gameOverText.setText(AppContext.getString("you-win") + " " + winner);
-				} else {
-					gameOverText.setText(AppContext.getString("you-lost-against") + " " + winner);
-				}
-			}
-
-			add(Pos.CENTER,
-				fit(vboxFill(
-					gameOverHeader,
-					separator(),
-
-					vspacer(),
-					gameOverText,
-					vspacer(),
-
-					separator(),
-					okButton
-				))
-			);
-		}
-	}
-
-	private final Button forfeitButton;
-	private final Button exitButton;
-
-	private final Text currentPlayerHeader;
-	private final Text currentMoveHeader;
-
-	private final Text nextPlayerHeader;
-
-    private final Text gameStateFeedback = text();
-
-	private final ListView<Text> chatListView;
-	private final TextField chatInput;
-
-	public GameView(Runnable onForfeit, Runnable onExit, Consumer<String> onMessage) {
-		assert onExit != null;
-
-		super(true, "bg-primary");
-
-		if (onForfeit != null) {
-			forfeitButton = button();
-			forfeitButton.setText(AppContext.getString("forfeit"));
-			forfeitButton.setOnAction(_ -> onForfeit.run());
-		} else {
-			forfeitButton = null;
-		}
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		if (onMessage != null) {
-			chatListView = new ListView<Text>();
-
-			chatInput = input();
-			chatInput.setOnAction(_ -> {
-				onMessage.accept(chatInput.getText());
-				chatInput.setText("");
-			});
-		} else {
-			chatListView = null;
-			chatInput = null;
-		}
-
-		exitButton = button();
-		exitButton.setText(AppContext.getString("exit"));
-		exitButton.setOnAction(_ -> onExit.run());
-
-		currentPlayerHeader = header("", "header");
-		currentMoveHeader = header();
-		nextPlayerHeader = header();
-	}
-
-	@Override
-	public void setup() {
-		add(
-                Pos.TOP_CENTER,
-                gameStateFeedback
-		);
-
-		add(Pos.BOTTOM_LEFT,
-                vboxFill(
-                    forfeitButton,
-                    exitButton
-                )
-        );
-
-		if (chatListView != null) {
-			add(Pos.BOTTOM_RIGHT,
-				fit(vboxFill(
-					chatListView,
-					chatInput
-				)
-			));
-		}
-	}
-
-	public void nextPlayer(boolean isMe, String currentPlayer, String currentMove, String nextPlayer) {
-        Platform.runLater(() -> {
-            gameStateFeedback.setText("Waiting on " + currentPlayer + " to make their move.");
-            currentPlayerHeader.setText(currentPlayer);
-            currentMoveHeader.setText(currentMove);
-
-            nextPlayerHeader.setText(nextPlayer);
-
-            if (isMe) {
-                currentPlayerHeader.getStyleClass().add("my-turn");
-            } else {
-                currentPlayerHeader.getStyleClass().remove("my-turn");
-            }
-        });
-
-	}
-
-	public void updateChat(String message) {
-		if (chatListView == null) {
-			return;
-		}
-
-		final Text messageText = text();
-		messageText.setText(message);
-
-		chatListView.getItems().add(messageText);
-	}
-
-	public void gameOver(boolean iWon, String winner) {
-		ViewStack.push(new GameOverView(iWon, winner));
-	}
-}

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

@@ -1,175 +0,0 @@
-package org.toop.app.view.views;
-
-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.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.app.widget.Primitive;
-import org.toop.app.widget.tutorial.BaseTutorialWidget;
-import org.toop.app.widget.tutorial.TicTacToeTutorialWidget;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.Node;
-import javafx.scene.control.Button;
-import javafx.scene.control.Slider;
-import javafx.scene.control.TextField;
-import javafx.scene.layout.VBox;
-import javafx.scene.text.Text;
-import org.toop.local.AppSettings;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public final class LocalMultiplayerView extends View {
-	private final GameInformation information;
-
-	public LocalMultiplayerView(GameInformation information) {
-		super(true, "bg-primary");
-		this.information = information;
-	}
-
-	public LocalMultiplayerView(GameInformation.Type type) {
-		this(new GameInformation(type));
-	}
-
-	@Override
-	public void setup() {
-		final Button playButton = button();
-		playButton.setText(AppContext.getString("play"));
-		playButton.setOnAction(_ -> {
-			for (final GameInformation.Player player : information.players) {
-				if (player.name.isEmpty()) {
-					ViewStack.push(new ErrorView(AppContext.getString("please-enter-your-name")));
-					return;
-				}
-			}
-
-			switch (information.type) {
-                case TICTACTOE: new TicTacToeGameThread(information); break;
-                case REVERSI: new ReversiGame(information); break;
-                case CONNECT4: new Connect4Game(information); break;
-                // case BATTLESHIP: new BattleshipGame(information); break;
-			}
-		});
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.CENTER,
-			fit(vboxFill(
-				hbox(
-					setupPlayers()
-				),
-
-				separator(),
-				playButton
-			))
-		);
-
-		final Button backButton = button();
-		backButton.setText(AppContext.getString("back"));
-		backButton.setOnAction(_ -> { ViewStack.push(new MainView()); });
-
-		add(Pos.BOTTOM_LEFT,
-			vboxFill(
-				backButton
-			)
-		);
-	}
-
-	private VBox[] setupPlayers() {
-		final VBox[] playerBoxes = new VBox[information.type.getPlayerCount()];
-
-		for (int i = 0; i < playerBoxes.length; i++) {
-			final int index = i;
-
-			List<Node> nodes = new ArrayList<>();
-
-			final Text playerHeader = header();
-			playerHeader.setText(AppContext.getString("player") + " #" + (i + 1));
-
-			nodes.add(playerHeader);
-			nodes.add(separator());
-
-			final Text nameText = text();
-			nameText.setText(AppContext.getString("name"));
-
-			if (information.players[i].isHuman) {
-				final Button playerToggle = button();
-				playerToggle.setText(AppContext.getString("player"));
-				playerToggle.setOnAction(_ -> {
-					information.players[index].isHuman = false;
-					cleanup();
-					setup();
-				});
-
-				nodes.add(vboxFill(playerToggle));
-
-				final TextField playerNameInput = input();
-				playerNameInput.setPromptText(AppContext.getString("enter-your-name"));
-				playerNameInput.setText(information.players[i].name);
-				playerNameInput.textProperty().addListener((_, _, newValue) -> {
-					information.players[index].name = newValue;
-				});
-
-				nodes.add(vboxFill(nameText, playerNameInput));
-			} else {
-				final Button computerToggle = button();
-				computerToggle.setText(AppContext.getString("computer"));
-				computerToggle.setOnAction(_ -> {
-					information.players[index].isHuman = true;
-					cleanup();
-					setup();
-				});
-
-				nodes.add(vboxFill(computerToggle));
-
-				information.players[i].name = "Pism Bot V" + i;
-
-				final Text computerNameText = text();
-				computerNameText.setText(information.players[index].name);
-
-				nodes.add(vboxFill(nameText, computerNameText));
-
-				final Text computerDifficultyText = text();
-				computerDifficultyText.setText(AppContext.getString("computer-difficulty"));
-
-				final Slider computerDifficultySlider = slider();
-				computerDifficultySlider.setMin(0);
-				computerDifficultySlider.setMax(information.type.getMaxDepth());
-				computerDifficultySlider.setValue(information.players[i].computerDifficulty);
-				computerDifficultySlider.valueProperty().addListener((_, _, newValue) -> {
-					information.players[index].computerDifficulty = newValue.intValue();
-				});
-
-				nodes.add(vboxFill(computerDifficultyText, computerDifficultySlider));
-
-				final Text computerThinkTimeText = text();
-				computerThinkTimeText.setText(AppContext.getString("computer-think-time"));
-
-				final Slider computerThinkTimeSlider = slider();
-				computerThinkTimeSlider.setMin(0);
-				computerThinkTimeSlider.setMax(5);
-				computerThinkTimeSlider.setValue(information.players[i].computerThinkTime);
-				computerThinkTimeSlider.valueProperty().addListener((_, _, newValue) -> {
-					information.players[index].computerThinkTime = newValue.intValue();
-				});
-
-				nodes.add(vboxFill(computerThinkTimeText, computerThinkTimeSlider));
-			}
-
-			playerBoxes[i] = vboxFill(nodes.toArray(new Node[0]));
-		}
-
-		return playerBoxes;
-	}
-}

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

@@ -1,57 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.GameInformation;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-
-public final class LocalView extends View {
-	public LocalView() {
-		super(true, "bg-primary");
-	}
-
-	@Override
-	public void setup() {
-		final Button ticTacToeButton = button();
-		ticTacToeButton.setText(AppContext.getString("tic-tac-toe"));
-		ticTacToeButton.setOnAction(_ -> { ViewStack.push(new LocalMultiplayerView(GameInformation.Type.TICTACTOE)); });
-
-		final Button reversiButton = button();
-		reversiButton.setText(AppContext.getString("reversi"));
-		reversiButton.setOnAction(_ -> { ViewStack.push(new LocalMultiplayerView(GameInformation.Type.REVERSI)); });
-
-        final Button connect4Button = button();
-        connect4Button.setText(AppContext.getString("connect4"));
-        connect4Button.setOnAction(_ -> { ViewStack.push(new LocalMultiplayerView(GameInformation.Type.CONNECT4)); });
-
-        add(Pos.CENTER,
-			fit(vboxFill(
-				ticTacToeButton,
-				reversiButton,
-                connect4Button
-			))
-		);
-
-		final Button backButton = button();
-		backButton.setText(AppContext.getString("back"));
-		backButton.setOnAction(_ -> { ViewStack.push(new MainView()); });
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.BOTTOM_LEFT,
-			vboxFill(
-				backButton
-			)
-		);
-	}
-}

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

@@ -1,55 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.App;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.local.AppContext;
-import org.toop.app.view.displays.SongDisplay;
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-
-public final class MainView extends View {
-	public MainView() {
-		super(true, "bg-primary");
-	}
-
-	@Override
-	public void setup() {
-		final Button localButton = button();
-		localButton.setText(AppContext.getString("local"));
-		localButton.setOnAction(_ -> { ViewStack.push(new LocalView()); });
-
-		final Button onlineButton = button();
-		onlineButton.setText(AppContext.getString("online"));
-		onlineButton.setOnAction(_ -> { ViewStack.push(new OnlineView()); });
-
-		final Button creditsButton = button();
-		creditsButton.setText(AppContext.getString("credits"));
-		creditsButton.setOnAction(_ -> { ViewStack.push(new CreditsView()); });
-
-		final Button optionsButton = button();
-		optionsButton.setText(AppContext.getString("options"));
-		optionsButton.setOnAction(_ -> { ViewStack.push(new OptionsView()); });
-
-		final Button quitButton = button();
-		quitButton.setText(AppContext.getString("quit"));
-		quitButton.setOnAction(_ -> { App.startQuit(); });
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-        add(Pos.BOTTOM_RIGHT,
-            fit(vboxFill(
-                    songdisplay
-                    )));
-
-		add(Pos.CENTER,
-			fit(vboxFill(
-				localButton,
-				onlineButton,
-				creditsButton,
-				optionsButton,
-				quitButton
-			))
-		);
-	}
-}

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

@@ -1,91 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.Server;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.control.TextField;
-import javafx.scene.text.Text;
-
-public class OnlineView extends View {
-	public OnlineView() {
-		super(true, "bg-primary");
-	}
-
-	@Override
-	public void setup() {
-		final Text serverInformationHeader = header();
-		serverInformationHeader.setText(AppContext.getString("server-information"));
-
-		final Text serverIPText = text();
-		serverIPText.setText(AppContext.getString("ip-address"));
-
-		final TextField serverIPInput = input();
-		serverIPInput.setPromptText(AppContext.getString("enter-the-server-ip"));
-
-		final Text serverPortText = text();
-		serverPortText.setText(AppContext.getString("port"));
-
-		final TextField serverPortInput = input();
-		serverPortInput.setPromptText(AppContext.getString("enter-the-server-port"));
-
-		final Text playerNameText = text();
-		playerNameText.setText(AppContext.getString("player-name"));
-
-		final TextField playerNameInput = input();
-		playerNameInput.setPromptText(AppContext.getString("enter-your-name"));
-
-		final Button connectButton = button();
-		connectButton.setText(AppContext.getString("connect"));
-		connectButton.setOnAction(_ -> {
-			new Server(serverIPInput.getText(), serverPortInput.getText(), playerNameInput.getText());
-		});
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.CENTER,
-			fit(vboxFill(
-				serverInformationHeader,
-				separator(),
-
-				vboxFill(
-					serverIPText,
-					serverIPInput
-				),
-
-				vboxFill(
-					serverPortText,
-					serverPortInput
-				),
-
-				vboxFill(
-					playerNameText,
-					playerNameInput
-				),
-
-				vboxFill(
-					connectButton
-				)
-			))
-		);
-
-		final Button backButton = button();
-		backButton.setText(AppContext.getString("back"));
-		backButton.setOnAction(_ -> { ViewStack.push(new MainView()); });
-
-		add(Pos.BOTTOM_LEFT,
-			vboxFill(
-				backButton
-			)
-		);
-	}
-}

app/src/main/java/org/toop/app/view/views/OptionsView.java

@@ -1,258 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.App;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.framework.audio.VolumeControl;
-import org.toop.framework.audio.events.AudioEvents;
-import org.toop.framework.eventbus.EventFlow;
-import org.toop.local.AppContext;
-import org.toop.local.AppSettings;
-
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.control.ComboBox;
-import javafx.scene.control.Slider;
-import javafx.scene.text.Text;
-import javafx.util.StringConverter;
-
-import java.util.Locale;
-
-public final class OptionsView extends View {
-	public OptionsView() {
-		super(false, "bg-secondary");
-	}
-
-	@Override
-	public void setup() {
-		final Text generalHeader = header();
-		generalHeader.setText(AppContext.getString("general"));
-
-		final Text volumeHeader = header();
-		volumeHeader.setText(AppContext.getString("volume"));
-
-		final Text styleHeader = header();
-		styleHeader.setText(AppContext.getString("style"));
-
-		add(Pos.CENTER,
-			fit(hboxFill(
-				vboxFill(
-					generalHeader,
-					separator(),
-
-					vboxFill(
-						text("language-text"),
-						combobox("language-combobox")
-					),
-
-					vboxFill(
-						button("fullscreen-button")
-					)
-				),
-
-				vboxFill(
-					volumeHeader,
-					separator(),
-
-					vboxFill(
-						text("master-volume-text"),
-						slider("master-volume-slider")
-					),
-
-					vboxFill(
-						text("effects-volume-text"),
-						slider("effects-volume-slider")
-					),
-
-					vboxFill(
-						text("music-volume-text"),
-						slider("music-volume-slider")
-					)
-				),
-
-				vboxFill(
-					styleHeader,
-					separator(),
-
-					vboxFill(
-						text("theme-text"),
-						combobox("theme-combobox")
-					),
-
-					vboxFill(
-						text("layout-text"),
-						combobox("layout-combobox")
-					)
-				)
-			))
-		);
-
-		setupLanguageOption();
-		setupMasterVolumeOption();
-		setupEffectsVolumeOption();
-		setupMusicVolumeOption();
-		setupThemeOption();
-		setupLayoutOption();
-		setupFullscreenOption();
-
-		final Button backButton = button();
-		backButton.setText(AppContext.getString("back"));
-		backButton.setOnAction(_ -> { ViewStack.pop(); });
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.BOTTOM_LEFT,
-			vboxFill(
-				backButton
-			)
-		);
-	}
-
-	private void setupLanguageOption() {
-		final Text languageText = get("language-text");
-		languageText.setText(AppContext.getString("language"));
-
-		final ComboBox<Locale> languageCombobox = get("language-combobox");
-		languageCombobox.getItems().addAll(AppContext.getLocalization().getAvailableLocales());
-		languageCombobox.setValue(AppContext.getLocale());
-
-		languageCombobox.getSelectionModel().selectedItemProperty().addListener((_, _, newValue) -> {
-			AppSettings.getSettings().setLocale(newValue.toString());
-			AppContext.setLocale(newValue);
-		});
-
-		languageCombobox.setConverter(new StringConverter<>() {
-			@Override
-			public String toString(Locale locale) {
-				return AppContext.getString(locale.getDisplayName().toLowerCase());
-			}
-
-			@Override
-			public Locale fromString(String s) {
-				return null;
-			}
-		});
-	}
-
-	private void setupMasterVolumeOption() {
-		final Text masterVolumeText = get("master-volume-text");
-		masterVolumeText.setText(AppContext.getString("master-volume"));
-
-		final Slider masterVolumeSlider = get("master-volume-slider");
-		masterVolumeSlider.setMin(0);
-		masterVolumeSlider.setMax(100);
-		masterVolumeSlider.setValue(AppSettings.getSettings().getVolume());
-
-		masterVolumeSlider.valueProperty().addListener((_, _, newValue) -> {
-			AppSettings.getSettings().setVolume(newValue.intValue());
-			new EventFlow().addPostEvent(new AudioEvents.ChangeVolume(newValue.doubleValue(), VolumeControl.MASTERVOLUME)).asyncPostEvent();
-		});
-	}
-
-	private void setupEffectsVolumeOption() {
-		final Text effectsVolumeText = get("effects-volume-text");
-		effectsVolumeText.setText(AppContext.getString("effects-volume"));
-
-		final Slider effectsVolumeSlider = get("effects-volume-slider");
-		effectsVolumeSlider.setMin(0);
-		effectsVolumeSlider.setMax(100);
-		effectsVolumeSlider.setValue(AppSettings.getSettings().getFxVolume());
-
-		effectsVolumeSlider.valueProperty().addListener((_, _, newValue) -> {
-			AppSettings.getSettings().setFxVolume(newValue.intValue());
-			new EventFlow().addPostEvent(new AudioEvents.ChangeVolume(newValue.doubleValue(), VolumeControl.FX)).asyncPostEvent();
-		});
-	}
-
-	private void setupMusicVolumeOption() {
-		final Text musicVolumeText = get("music-volume-text");
-		musicVolumeText.setText(AppContext.getString("music-volume"));
-
-		final Slider musicVolumeSlider = get("music-volume-slider");
-		musicVolumeSlider.setMin(0);
-		musicVolumeSlider.setMax(100);
-		musicVolumeSlider.setValue(AppSettings.getSettings().getMusicVolume());
-
-		musicVolumeSlider.valueProperty().addListener((_, _, newValue) -> {
-			AppSettings.getSettings().setMusicVolume(newValue.intValue());
-			new EventFlow().addPostEvent(new AudioEvents.ChangeVolume(newValue.doubleValue(), VolumeControl.MUSIC)).asyncPostEvent();
-		});
-	}
-
-	private void setupThemeOption() {
-		final Text themeText = get("theme-text");
-		themeText.setText(AppContext.getString("theme"));
-
-		final ComboBox<String> themeCombobox = get("theme-combobox");
-		themeCombobox.getItems().addAll("dark", "light", "high-contrast");
-		themeCombobox.setValue(AppSettings.getSettings().getTheme());
-
-		themeCombobox.getSelectionModel().selectedItemProperty().addListener((_, _, newValue) -> {
-			AppSettings.getSettings().setTheme(newValue);
-			App.setStyle(newValue, AppSettings.getSettings().getLayoutSize());
-		});
-
-		themeCombobox.setConverter(new StringConverter<>() {
-			@Override
-			public String toString(String theme) {
-				return AppContext.getString(theme);
-			}
-
-			@Override
-			public String fromString(String s) {
-				return null;
-			}
-		});
-	}
-
-	private void setupLayoutOption() {
-		final Text layoutText = get("layout-text");
-		layoutText.setText(AppContext.getString("layout-size"));
-
-		final ComboBox<String> layoutCombobox = get("layout-combobox");
-		layoutCombobox.getItems().addAll("small", "medium", "large");
-		layoutCombobox.setValue(AppSettings.getSettings().getLayoutSize());
-
-		layoutCombobox.getSelectionModel().selectedItemProperty().addListener((_, _, newValue) -> {
-			AppSettings.getSettings().setLayoutSize(newValue);
-			App.setStyle(AppSettings.getSettings().getTheme(), newValue);
-		});
-
-		layoutCombobox.setConverter(new StringConverter<>() {
-			@Override
-			public String toString(String layout) {
-				return AppContext.getString(layout);
-			}
-
-			@Override
-			public String fromString(String s) {
-				return null;
-			}
-		});
-	}
-
-	private void setupFullscreenOption() {
-		final Button fullscreenButton = get("fullscreen-button");
-
-		if (AppSettings.getSettings().getFullscreen()) {
-			fullscreenButton.setText(AppContext.getString("windowed"));
-			fullscreenButton.setOnAction(_ -> {
-				AppSettings.getSettings().setFullscreen(false);
-				App.setFullscreen(false);
-			});
-		} else {
-			fullscreenButton.setText(AppContext.getString("fullscreen"));
-			fullscreenButton.setOnAction(_ -> {
-				AppSettings.getSettings().setFullscreen(true);
-				App.setFullscreen(true);
-			});
-		}
-	}
-}

app/src/main/java/org/toop/app/view/views/QuitView.java

@@ -1,40 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.App;
-import org.toop.app.view.View;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.text.Text;
-
-public final class QuitView extends View {
-	public QuitView() {
-		super(false, "bg-popup");
-	}
-
-	@Override
-	public void setup() {
-		final Text sureHeader = header();
-		sureHeader.setText(AppContext.getString("are-you-sure"));
-
-		final Button yesButton = button();
-		yesButton.setText(AppContext.getString("yes"));
-		yesButton.setOnAction(_ -> { App.quit(); });
-
-		final Button noButton = button();
-		noButton.setText(AppContext.getString("no"));
-		noButton.setOnAction(_ -> { App.stopQuit(); });
-
-		add(Pos.CENTER,
-			fit(vbox(
-				sureHeader,
-
-				hbox(
-					yesButton,
-					noButton
-				)
-			))
-		);
-	}
-}

app/src/main/java/org/toop/app/view/views/SendChallengeView.java

@@ -1,119 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.GameInformation;
-import org.toop.app.Server;
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.local.AppContext;
-
-import javafx.geometry.Pos;
-import javafx.scene.Node;
-import javafx.scene.control.Button;
-import javafx.scene.control.ComboBox;
-import javafx.scene.control.Slider;
-import javafx.scene.text.Text;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.function.BiConsumer;
-
-public final class SendChallengeView extends View {
-	private final Server server;
-	private final String opponent;
-	private final BiConsumer<GameInformation.Player, String> onSend;
-
-	private final GameInformation.Player playerInformation;
-
-	public SendChallengeView(Server server, String opponent, BiConsumer<GameInformation.Player, String> onSend) {
-		super(false, "bg-popup");
-
-		this.server = server;
-		this.opponent = opponent;
-		this.onSend = onSend;
-
-		playerInformation = new GameInformation.Player();
-	}
-
-	@Override
-	public void setup() {
-		final Text challengeText = text();
-		challengeText.setText(AppContext.getString("challenge"));
-
-		final Text opponentHeader = header();
-		opponentHeader.setText(opponent);
-
-		final Text gameText = text();
-		gameText.setText(AppContext.getString("to-a-game-of"));
-
-		final ComboBox<String> gamesCombobox = combobox();
-		gamesCombobox.getItems().addAll(server.getGameList());
-		gamesCombobox.setValue(gamesCombobox.getItems().getFirst());
-
-		final Button sendButton = button();
-		sendButton.setText(AppContext.getString("send"));
-		sendButton.setOnAction(_ -> { onSend.accept(playerInformation, gamesCombobox.getValue()); });
-
-		final Button cancelButton = button();
-		cancelButton.setText(AppContext.getString("cancel"));
-		cancelButton.setOnAction(_ -> {
-            ViewStack.pop(); });
-
-		final List<Node> nodes = new ArrayList<>();
-
-		if (playerInformation.isHuman) {
-			final Button playerToggle = button();
-			playerToggle.setText(AppContext.getString("player"));
-			playerToggle.setOnAction(_ -> {
-				playerInformation.isHuman = false;
-				cleanup();
-				setup();
-			});
-
-			nodes.add(vbox(playerToggle));
-		} else {
-			final Button computerToggle = button();
-			computerToggle.setText(AppContext.getString("computer"));
-			computerToggle.setOnAction(_ -> {
-				playerInformation.isHuman = true;
-				cleanup();
-				setup();
-			});
-
-			nodes.add(vbox(computerToggle));
-
-			final Text computerDifficultyText = text();
-			computerDifficultyText.setText(AppContext.getString("computer-difficulty"));
-
-			final Slider computerDifficultySlider = slider();
-			computerDifficultySlider.setMin(0);
-			computerDifficultySlider.setMax(Server.gameToType(gamesCombobox.getValue()).getMaxDepth());
-			computerDifficultySlider.setValue(playerInformation.computerDifficulty);
-			computerDifficultySlider.valueProperty().addListener((_, _, newValue) -> {
-				playerInformation.computerDifficulty = newValue.intValue();
-			});
-
-			nodes.add(vbox(computerDifficultyText, computerDifficultySlider));
-		}
-
-		add(Pos.CENTER,
-			fit(hboxFill(
-				vboxFill(
-					challengeText,
-					opponentHeader,
-					gameText,
-					gamesCombobox,
-					separator(),
-
-					hboxFill(
-						sendButton,
-						cancelButton
-					)
-				),
-
-				vboxFill(
-					nodes.toArray(new Node[0])
-				)
-			))
-		);
-	}
-}

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

@@ -1,89 +0,0 @@
-package org.toop.app.view.views;
-
-import org.toop.app.view.View;
-import org.toop.app.view.ViewStack;
-import org.toop.app.view.displays.SongDisplay;
-import org.toop.local.AppContext;
-
-import javafx.application.Platform;
-import javafx.geometry.Pos;
-import javafx.scene.control.Button;
-import javafx.scene.control.ListView;
-import javafx.scene.text.Text;
-
-import java.util.List;
-import java.util.function.Consumer;
-
-public final class ServerView extends View {
-	private final String user;
-	private final Consumer<String> onPlayerClicked;
-	private final Runnable onDisconnect;
-
-	private ListView<Button> listView;
-
-	public ServerView(String user, Consumer<String> onPlayerClicked, Runnable onDisconnect) {
-		super(true, "bg-primary");
-
-		this.user = user;
-		this.onPlayerClicked = onPlayerClicked;
-		this.onDisconnect = onDisconnect;
-	}
-
-	public void update(List<String> players) {
-		Platform.runLater(() -> {
-			listView.getItems().clear();
-
-			for (int i = 0; i < players.size(); i++) {
-				final int finalI = i;
-
-				final Button button = button();
-				button.setText(players.get(i));
-				button.setOnAction(_ -> {
-					onPlayerClicked.accept(players.get(finalI));
-				});
-
-				listView.getItems().add(button);
-			}
-		});
-	}
-
-	@Override
-	public void setup() {
-		final Text playerHeader = header();
-		playerHeader.setText(user);
-
-		listView = new ListView<Button>();
-
-        final SongDisplay songdisplay = new SongDisplay();
-
-
-        add(Pos.BOTTOM_RIGHT,
-                fit(vboxFill(
-                        songdisplay
-                )));
-
-		add(Pos.CENTER,
-			fit(vboxFill(
-				vbox(
-					playerHeader,
-					separator()
-				),
-
-				listView
-			))
-		);
-
-		final Button disconnectButton = button();
-		disconnectButton.setText(AppContext.getString("disconnect"));
-		disconnectButton.setOnAction(_ -> {
-			onDisconnect.run();
-			ViewStack.push(new OnlineView());
-		});
-
-		add(Pos.BOTTOM_LEFT,
-			vboxFill(
-				disconnectButton
-			)
-		);
-	}
-}

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

@@ -1,11 +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;
 
 import javafx.collections.FXCollections;
@@ -22,33 +22,40 @@ import javafx.scene.layout.VBox;
 import javafx.scene.text.Text;
 import javafx.util.StringConverter;
 
-public final class  Primitive {
+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));
+			if (localize) header.setText(AppContext.getString(key)); else header.setText(key);
-			header.textProperty().bind(AppContext.bindToKey(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));
+			if (localize) text.setText(AppContext.getString(key)); else text.setText(key);
-			text.textProperty().bind(AppContext.bindToKey(key));
+			text.textProperty().bind(AppContext.bindToKey(key, localize));
 		}
 
 		return text;
 	}
 
-    public static ImageView image(File file) {
+	public static Text text(String key) {
-        ImageAsset imageAsset = new ImageAsset(file);
+		return text(key, true);
+	}
+
+    public static ImageView image(ImageAsset imageAsset) {
         ImageView imageView = new ImageView(imageAsset.getImage());
         imageView.getStyleClass().add("image");
         imageView.setPreserveRatio(true);
@@ -57,30 +64,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));
+			if (localize) button.setText(AppContext.getString(key));  else button.setText(key);
-			button.textProperty().bind(AppContext.bindToKey(key));
+			button.textProperty().bind(AppContext.bindToKey(key, localize));
 		}
 
 		if (onAction != null) {
-			button.setOnAction(_ ->
+			button.setOnAction(_ -> {
-				onAction.run());
+                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));
+			if (localize) input.setPromptText(AppContext.getString(promptKey)); else input.setPromptText(promptKey);
-			input.promptTextProperty().bind(AppContext.bindToKey(promptKey));
+			input.promptTextProperty().bind(AppContext.bindToKey(promptKey, localize));
 		}
 
 		input.setText(text);
@@ -93,6 +106,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,12 +118,17 @@ public final class  Primitive {
 		slider.setMax(max);
 		slider.setValue(value);
 
-		if (onValueChanged != null) {
+        if (onValueChanged != null) {
-			slider.valueProperty().addListener((_, _, newValue) ->
+            slider.valueProperty().addListener((_, _, newValue) -> {
-				onValueChanged.accept(newValue.intValue()));
+                onValueChanged.accept(newValue.intValue());
-		}
+            });
+        }
 
-		return slider;
+        slider.setOnMouseReleased(event -> {
+            playButtonSound();
+        });
+
+        return slider;
 	}
 
 	@SafeVarargs
@@ -123,9 +145,11 @@ public final class  Primitive {
 		}
 
 		if (onValueChanged != null) {
-			choice.valueProperty().addListener((_, _, newValue) ->
+            choice.valueProperty().addListener((_, _, newValue) -> {
-				onValueChanged.accept(newValue));
+                onValueChanged.accept(newValue);
-		}
+                playButtonSound();
+            });
+        }
 
 		choice.setItems(FXCollections.observableArrayList(items));
 
@@ -177,4 +201,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/Updatable.java

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

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

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

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

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

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

@@ -0,0 +1,162 @@
+package org.toop.app.widget.complex;
+
+import javafx.application.Platform;
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+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((Node) this);
+            return;
+        } else if (failureTrigger.call()) {
+            triggerFailure();
+            this.remove((Node) this);
+            return;
+        }
+
+        if (maxAmount != 0) {
+            percentage = (float) amount / maxAmount;
+        }
+        if (!isInfinite) {
+            progressBar.setProgress(percentage);
+        }
+    }
+}

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

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

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

@@ -1,7 +1,21 @@
 package org.toop.app.widget.complex;
 
+import javafx.geometry.Pos;
+import javafx.scene.control.Button;
+
 public abstract class PopupWidget extends StackWidget {
+	private final Button popButton;
+
 	public PopupWidget() {
 		super("bg-popup");
+
+		popButton = new Button("X");
+		popButton.setOnAction(_ -> hide());
+
+		add(Pos.TOP_RIGHT, popButton);
+	}
+
+	protected void setOnPop(Runnable onPop) {
+		popButton.setOnAction(_ -> onPop.run());
 	}
 }

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

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

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;
@@ -29,8 +31,9 @@ public class ToggleWidget implements Widget {
 			state = !state;
 			updateText();
 			if (onToggle != null) {
-				onToggle.accept(state);
+                onToggle.accept(state);
-			}
+                new EventFlow().addPostEvent(new AudioEvents.ClickButton()).postEvent(); // TODO FIX PRIMITIVES
+            }
 		});
 
 		container = Primitive.vbox(button);

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

@@ -16,8 +16,18 @@ public abstract class ViewWidget extends StackWidget {
 		replace(Pos.CENTER, view);
 	}
 
-	public void transitionNext(ViewWidget view) {
+    public void transitionNext(ViewWidget view) {
-		view.previous = this;
+        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", () -> {
@@ -27,6 +37,19 @@ public abstract class ViewWidget extends StackWidget {
 		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(backButton));
 	}
 
+	public void transitionNextCustom(ViewWidget view, String key, Runnable runnable) {
+		view.previous = this;
+
+		replace(Pos.CENTER, view);
+
+		var customButton = Primitive.button(key, () -> {
+			runnable.run();
+			view.transitionPrevious();
+		});
+
+		view.add(Pos.BOTTOM_LEFT, Primitive.vbox(customButton));
+	}
+
 	public void transitionPrevious() {
 		if (previous == null) {
 			return;
@@ -36,6 +59,38 @@ public abstract class ViewWidget extends StackWidget {
 		previous = null;
 	}
 
+	public void removeIndexFromPreviousChain(int index) {
+		ViewWidget view = this;
+
+		while (index > 0 && view != null) {
+			index--;
+
+			if (index == 0) {
+				if (view.previous != null && view.previous.previous != null) {
+					view.previous = view.previous.previous;
+				}
+			}
+
+			view = view.previous;
+		}
+	}
+
+	public void removeViewFromPreviousChain(ViewWidget view) {
+		ViewWidget prev = previous;
+		int index = 0;
+
+		while (prev != null) {
+			index++;
+
+			if (prev == view) {
+				removeIndexFromPreviousChain(index);
+				break;
+			}
+
+			prev = prev.previous;
+		}
+	}
+
 	public void reload(ViewWidget view) {
 		view.previous = previous;
 		replace(Pos.CENTER, view);

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

@@ -22,7 +22,7 @@ public class SongDisplay extends VBox implements Widget {
 
 	public SongDisplay() {
 		new EventFlow()
-			.listen(this::updateTheSong);
+				.listen(AudioEvents.PlayingMusic.class, this::updateTheSong, false);
 
 		setAlignment(Pos.CENTER);
 		setMaxHeight(Region.USE_PREF_SIZE);
@@ -33,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");
@@ -49,11 +49,11 @@ public class SongDisplay extends VBox implements Widget {
 		previousButton.getStyleClass().setAll("previous-button");
 
 		skipButton.setOnAction( event -> {
-			GlobalEventBus.post(new AudioEvents.SkipMusic());
+			GlobalEventBus.get().post(new AudioEvents.SkipMusic());
 		});
 
 		pauseButton.setOnAction(event -> {
-			GlobalEventBus.post(new AudioEvents.PauseMusic());
+			GlobalEventBus.get().post(new AudioEvents.PauseMusic());
 			if (pauseButton.getText().equals("⏸")) {
 				pauseButton.setText("▶");
 			}
@@ -63,7 +63,7 @@ public class SongDisplay extends VBox implements Widget {
 		});
 
 		previousButton.setOnAction( event -> {
-			GlobalEventBus.post(new AudioEvents.PreviousMusic());
+			GlobalEventBus.get().post(new AudioEvents.PreviousMusic());
 		});
 
 		HBox control = new HBox(10, previousButton, pauseButton, skipButton);

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

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

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

@@ -0,0 +1,48 @@
+package org.toop.app.widget.popup;
+
+import javafx.geometry.Pos;
+import javafx.scene.Node;
+import org.toop.app.widget.Primitive;
+import org.toop.app.widget.Widget;
+import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.PopupWidget;
+import org.toop.app.widget.complex.ViewWidget;
+import org.toop.app.widget.view.GameView;
+import org.toop.app.widget.view.OptionsView;
+import org.toop.local.AppContext;
+
+import java.util.ArrayList;
+
+public class EscapePopup extends PopupWidget {
+    public EscapePopup() {
+        ViewWidget currentView = WidgetContainer.getCurrentView();
+        ArrayList<Node> nodes = new ArrayList<>();
+
+        nodes.add(Primitive.button("Continue", this::hide, false)); // TODO, localize
+
+        if (!(currentView.getClass().isAssignableFrom(OptionsView.class))) {
+            var opt = Primitive.button("options", () -> {
+                hide();
+                WidgetContainer.getCurrentView().transitionNext(new OptionsView());
+            });
+            nodes.add(opt);
+        }
+
+        if (currentView.getClass().isAssignableFrom(GameView.class)) {
+            Widget tut = AppContext.currentTutorial();
+            if (tut != null) {
+                nodes.add(Primitive.button("tutorialstring", () -> {
+                    WidgetContainer.getCurrentView().add(Pos.CENTER, tut);
+                }));
+            }
+        }
+
+        nodes.add(Primitive.button("quit", () -> {
+            hide();
+            WidgetContainer.add(Pos.CENTER, new QuitPopup());
+        }));
+
+        add(Pos.CENTER, Primitive.vbox(nodes.toArray(new Node[0])));
+
+    }
+}

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

@@ -2,23 +2,21 @@ package org.toop.app.widget.popup;
 
 import org.toop.app.widget.complex.ConfirmWidget;
 import org.toop.app.widget.complex.PopupWidget;
-import org.toop.local.AppContext;
 
 import javafx.geometry.Pos;
 
 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()) {
+        if (winOrTie) {
-			confirmWidget.setMessage(AppContext.getString("the-game-ended-in-a-draw"));
+            confirmWidget.setMessage(winner + " won the game!");
-		} else if (iWon) {
+        }
-			confirmWidget.setMessage(AppContext.getString("you-win"));
+        else{
-		} else {
+            confirmWidget.setMessage("It was a tie!");
-			confirmWidget.setMessage(AppContext.getString("you-lost-against") + ": " + winner);
+        }
-		}
 
-		confirmWidget.addButton("ok", () -> hide());
+		confirmWidget.addButton("ok", this::hide);
 
 		add(Pos.CENTER, confirmWidget);
 	}

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

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

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

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

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

@@ -1,60 +1,112 @@
 package org.toop.app.widget.tutorial;
 
 import javafx.geometry.Pos;
+import javafx.scene.control.Button;
 import javafx.scene.image.ImageView;
 import javafx.scene.text.Text;
+import org.apache.maven.surefire.shared.lang3.tuple.ImmutablePair;
 import org.toop.app.widget.Primitive;
-import org.toop.app.widget.complex.ViewWidget;
+import org.toop.app.widget.Updatable;
+import org.toop.app.widget.complex.PopupWidget;
 
-import javafx.scene.control.Button;
+import org.toop.framework.resource.resources.ImageAsset;
 import org.toop.local.AppContext;
 
-import java.io.File;
+import java.util.List;
 
-public class BaseTutorialWidget extends ViewWidget {
+/**
+ * A widget base for all the tutorial widgets.
+ *
+ * <p>Usage example:
+ *
+ * <pre>{@code
+ * public class Connect4TutorialWidget extends BaseTutorialWidget {
+ *     public Connect4TutorialWidget(Runnable nextScreen) {
+ *         super(List.of(
+ *                 new ImmutablePair<>("connect4.1", ResourceManager.get("connect41.png")),
+ *                 new ImmutablePair<>("connect4.2", ResourceManager.get("connect42.png"))
+ *         ), nextScreen);
+ *     }
+ * }</pre>
+ */
+public class BaseTutorialWidget extends PopupWidget implements Updatable {
 
-    private TState state;
+    private final Text tutorialText;
-    private Text tutorialText;
+    private final ImageView imagery;
-    private Button previousButton;
+    private final Button previousButton;
-    private Button nextButton;
+    private final Button nextButton;
-    private Button noButton;
+    private final List<ImmutablePair<String, ImageAsset>> pages;
-    private Button yesButton;
+    private final Runnable nextScreen;
-    private Button neverButton;
-    private ImageView imagery;
 
-    public BaseTutorialWidget(String key, Runnable onNo, Runnable onYes, Runnable onNever) {
+    private int pageIndex = 0;
-        System.out.println("Trying to initialize...");
-        this.tutorialText = Primitive.text(key);
-        this.yesButton = Primitive.button("ok", () -> onYes.run());
-        this.noButton = Primitive.button("no", () -> onNo.run());
-        this.neverButton = Primitive.button("never", () -> onNever.run());
-        var a = Primitive.hbox(yesButton, noButton, neverButton);
-        add(Pos.CENTER, Primitive.vbox(tutorialText, a));
-    }
 
-    public BaseTutorialWidget(TState state, String key, Runnable onPrevious, Runnable onNext) {
+    public BaseTutorialWidget(List<ImmutablePair<String, ImageAsset>> pages, Runnable nextScreen) {
-        this.state = state;
+        this.tutorialText = Primitive.text(pages.getFirst().getKey());
-        this.tutorialText = Primitive.text(key);
+        this.imagery = Primitive.image(pages.getFirst().getValue());
-        this.previousButton = Primitive.button("<", () -> onPrevious.run());
+
-        this.nextButton = Primitive.button(">", () -> onNext.run());
+        this.pages = pages;
-        var w = Primitive.hbox(previousButton, nextButton);
+        this.nextScreen = nextScreen;
-        add(Pos.CENTER, Primitive.vbox(tutorialText, w));
+
-    }
+        previousButton = Primitive.button("goback", () -> { update(false); this.hide(); });
+        nextButton = Primitive.button(">", () -> update(true));
+
+        var w = Primitive.hbox(
+                previousButton,
+                nextButton
+        );
+
+        var x = Primitive.vbox(imagery, tutorialText);
 
-    public BaseTutorialWidget(TState state, String key, File image,  Runnable onPrevious, Runnable onNext) {
-        this.state = state;
-        this.imagery = Primitive.image(image);
-        this.tutorialText = Primitive.text(key);
-        this.previousButton = Primitive.button("<", () -> onPrevious.run());
-        this.nextButton = Primitive.button(">", () -> onNext.run());
-        var w = Primitive.hbox(previousButton, nextButton);
-        var x =  Primitive.vbox(imagery, tutorialText);
         add(Pos.CENTER, Primitive.vbox(x, w));
     }
 
-    public void update(String key, File image) {
+    @Override
+    public void update() {
+        update(true);
+    }
+
+    // TODO Refactor if statements to make code easier to read.
+    public void update(boolean next) {
+        pageIndex = next ? pageIndex + 1 : pageIndex - 1;
+
+        if (pageIndex >= pages.size()) {
+            pageIndex--;
+            return;
+        } else if (pageIndex < 0) {
+            pageIndex++;
+            return;
+        }
+
+        if (pageIndex == pages.size()-1) {
+            nextButton.textProperty().unbind();
+            nextButton.setText(AppContext.getString("startgame"));
+            nextButton.setOnAction((_) ->  {
+                this.hide();
+                nextScreen.run();
+            });
+        } else {
+            nextButton.textProperty().unbind();
+            nextButton.setText(AppContext.getString(">"));
+            nextButton.setOnAction((_) -> this.update(true));
+        }
+
+        if (pageIndex == 0) {
+            previousButton.textProperty().unbind();
+            previousButton.setText(AppContext.getString("goback"));
+            previousButton.setOnAction((_) -> this.hide());
+        } else {
+            previousButton.textProperty().unbind();
+            previousButton.setText(AppContext.getString("<"));
+            previousButton.setOnAction((_) -> this.update(false));
+        }
+
+        var currentPage = pages.get(pageIndex);
+
+        var text = currentPage.getKey();
+        var image = currentPage.getValue();
+
         tutorialText.textProperty().unbind();
-        tutorialText.setText(AppContext.getString(key));
+        tutorialText.setText(AppContext.getString(text));
         imagery.setImage(Primitive.image(image).getImage());
     }
 }

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

@@ -1,39 +1,15 @@
 package org.toop.app.widget.tutorial;
 
-import javafx.geometry.Pos;
+import org.apache.maven.surefire.shared.lang3.tuple.ImmutablePair;
-import org.toop.app.widget.complex.ViewWidget;
+import org.toop.framework.resource.ResourceManager;
 
-import java.io.File;
+import java.util.List;
 
-public class Connect4TutorialWidget extends ViewWidget {
+public class Connect4TutorialWidget extends BaseTutorialWidget {
-    private TState state;
+    public Connect4TutorialWidget(Runnable nextScreen) {
-    private String[] keys = {"connect4.1", "connect4.2"};
+        super(List.of(
-    private File[] images = {new File("app/src/main/resources/assets/images/connect41.png"), new File("app/src/main/resources/assets/images/connect42.png")};
+                new ImmutablePair<>("connect4.1", ResourceManager.get("connect41.png")),
-    private BaseTutorialWidget tutorialWidget;
+                new ImmutablePair<>("connect4.2", ResourceManager.get("connect42.png"))
-
+        ), nextScreen);
-    public Connect4TutorialWidget() {
-        this.state = new TState(keys.length);
-        tutorialWidget = new BaseTutorialWidget(
-                state,
-                keys[state.getCurrent()],
-                images[state.getCurrent()],
-                () -> {
-                    if (state.hasPrevious()) {
-                        state.previous();
-                        update();
-                    }
-                },
-                () -> {
-                    if (state.hasNext()) {
-                        state.next();
-                        update();
-                    }
-                }
-        );
-        add(Pos.CENTER, tutorialWidget);
-    }
-
-    private void update() {
-        tutorialWidget.update(keys[state.getCurrent()], images[state.getCurrent()]);
     }
 }

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

@@ -1,39 +1,17 @@
 package org.toop.app.widget.tutorial;
 
-import javafx.geometry.Pos;
+import org.apache.maven.surefire.shared.lang3.tuple.ImmutablePair;
-import org.toop.app.widget.complex.ViewWidget;
+import org.toop.framework.resource.ResourceManager;
 
-import java.io.File;
+import java.util.List;
 
-public class ReversiTutorialWidget extends ViewWidget {
+public class ReversiTutorialWidget extends BaseTutorialWidget {
-    private TState state;
+    public ReversiTutorialWidget(Runnable nextScreen) {
-    private String[] keys = {"reversi1", "reversi2", "reversi3", "reversi4"};
+        super(List.of(
-    private File[] images = {new File("app/src/main/resources/assets/images/reversi1.png"), new File("app/src/main/resources/assets/images/reversi2.png"),  new File("app/src/main/resources/assets/images/cat.jpg"), new File("app/src/main/resources/assets/images/cat.jpg")};
+                new ImmutablePair<>("reversi1", ResourceManager.get("reversi1.png")),
-    private BaseTutorialWidget tutorialWidget;
+                new ImmutablePair<>("reversi2", ResourceManager.get("reversi2.png")),
-
+                new ImmutablePair<>("reversi3", ResourceManager.get("cat.jpg")),
-    public ReversiTutorialWidget() {
+                new ImmutablePair<>("reversi4", ResourceManager.get("cat.jpg"))
-        this.state = new TState(keys.length);
+        ), nextScreen);
-        tutorialWidget = new BaseTutorialWidget(
-                state,
-                keys[state.getCurrent()],
-                images[state.getCurrent()],
-                () -> {
-                    if (state.hasPrevious()) {
-                        state.previous();
-                        update();
-                    }
-                },
-                () -> {
-                    if (state.hasNext()) {
-                        state.next();
-                        update();
-                    }
-                }
-        );
-        add(Pos.CENTER, tutorialWidget);
-    }
-
-    private void update() {
-        tutorialWidget.update(keys[state.getCurrent()], images[state.getCurrent()]);
     }
 }

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

@@ -0,0 +1,22 @@
+package org.toop.app.widget.tutorial;
+
+import javafx.geometry.Pos;
+import org.toop.app.widget.Primitive;
+import org.toop.app.widget.WidgetContainer;
+import org.toop.app.widget.complex.PopupWidget;
+import org.toop.local.AppSettings;
+
+public class ShowEnableTutorialWidget extends PopupWidget {
+
+    public ShowEnableTutorialWidget(Runnable tutorial, Runnable nextScreen, Runnable appSettingsSetter) {
+        var a = Primitive.hbox(
+                Primitive.button("ok", () -> { appSettingsSetter.run(); tutorial.run(); this.hide(); }),
+                Primitive.button("no", () -> { appSettingsSetter.run(); nextScreen.run(); this.hide(); }),
+                Primitive.button("never", () -> { AppSettings.getSettings().setTutorialFlag(false); nextScreen.run(); this.hide(); })
+        );
+
+        var txt = Primitive.text("tutorial");
+        add(Pos.CENTER, Primitive.vbox(txt, a));
+        WidgetContainer.add(Pos.CENTER, this);
+    }
+}

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

@@ -1,44 +0,0 @@
-package org.toop.app.widget.tutorial;
-
-public class TState {
-
-    private int current;
-    private int total;
-
-    public TState(int total) {
-        this.total = total;
-        this.current = 0;
-    }
-
-    public int getCurrent() {
-        return current;
-    }
-
-    public void setCurrent(int current) {
-        this.current = current;
-    }
-
-    public int getTotal() {
-        return total;
-    }
-
-    public void setTotal(int total) {
-        this.total = total;
-    }
-
-    public void next() {
-        current = current + 1;
-    }
-
-    public void previous() {
-        current = current - 1;
-    }
-
-    public boolean hasNext() {
-        return current < total - 1;
-    }
-
-    public boolean hasPrevious() {
-        return current > 0;
-    }
-}

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

@@ -1,42 +1,16 @@
 package org.toop.app.widget.tutorial;
 
-import javafx.geometry.Pos;
+import org.apache.maven.surefire.shared.lang3.tuple.ImmutablePair;
-import org.toop.app.widget.complex.ViewWidget;
+import org.toop.framework.resource.ResourceManager;
-import java.io.File;
 
-public class TicTacToeTutorialWidget extends ViewWidget {
+import java.util.List;
 
-    private TState state;
+public class TicTacToeTutorialWidget extends BaseTutorialWidget {
-    private String[] keys = {"tictactoe1", "tictactoe2"};
+    public TicTacToeTutorialWidget(Runnable nextScreen) {
-    private File[] images = {
+        super(List.of(
-            new File("app/src/main/resources/assets/images/tictactoe1.png"),
+                new ImmutablePair<>("tictactoe1", ResourceManager.get("tictactoe1.png")),
-            new File("app/src/main/resources/assets/images/tictactoe2.png")
+                new ImmutablePair<>("tictactoe2", ResourceManager.get("tictactoe2.png"))
-    };
+        ), nextScreen);
-    private BaseTutorialWidget tutorialWidget;
-
-    public TicTacToeTutorialWidget() {
-        this.state = new TState(keys.length);
-        tutorialWidget = new BaseTutorialWidget(
-            state,
-            keys[state.getCurrent()],
-            images[state.getCurrent()],
-            () -> {
-                if (state.hasPrevious()) {
-                    state.previous();
-                    update();
-                }
-            },
-            () -> {
-                if (state.hasNext()) {
-                    state.next();
-                    update();
-                }
-            }
-        );
-        add(Pos.CENTER, tutorialWidget);
     }
 
-    private void update() {
-        tutorialWidget.update(keys[state.getCurrent()], images[state.getCurrent()]);
-    }
 }

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

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

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

@@ -2,27 +2,33 @@ 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.gameControllers.ReversiBitController;
-import org.toop.app.game.ReversiGame;
+import org.toop.app.gameControllers.TicTacToeBitController;
-import org.toop.app.game.TicTacToeGameThread;
+import org.toop.framework.gameFramework.controller.GameController;
+import org.toop.framework.gameFramework.model.player.Player;
+import org.toop.game.games.reversi.BitboardReversi;
+import org.toop.game.games.tictactoe.BitboardTicTacToe;
+import org.toop.game.players.ArtificialPlayer;
+import org.toop.game.players.LocalPlayer;
 import org.toop.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.app.widget.tutorial.BaseTutorialWidget;
+import org.toop.app.widget.tutorial.*;
-import org.toop.app.widget.tutorial.Connect4TutorialWidget;
+import org.toop.game.players.ai.MiniMaxAI;
-import org.toop.app.widget.tutorial.ReversiTutorialWidget;
+import org.toop.game.players.ai.RandomAI;
-import org.toop.app.widget.tutorial.TicTacToeTutorialWidget;
 import org.toop.local.AppContext;
 
 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 GameController gameController;
+
 	public LocalMultiplayerView(GameInformation.Type type) {
 		this(new GameInformation(type));
 	}
@@ -30,6 +36,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);
@@ -37,94 +46,69 @@ public class LocalMultiplayerView extends ViewWidget {
 				}
 			}
 
+            // TODO: Fix this temporary ass way of setting the players
+            Player[] players = new Player[2];
+
 			switch (information.type) {
                 case TICTACTOE:
-                    if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
+                    if (information.players[0].isHuman) {
-                         BaseTutorialWidget a = new BaseTutorialWidget(
+                        players[0] = new LocalPlayer<>(information.players[0].name);
-                                "tutorial",
+                    } else {
-                                () -> {
+                        players[0] = new ArtificialPlayer<>(new RandomAI<BitboardTicTacToe>(), "Random AI");
-                                    AppSettings.getSettings().setFirstTTT(false);
+                    }
-                                    Platform.runLater(() -> {
+                    if (information.players[1].isHuman) {
-                                        new TicTacToeGameThread(information);
+                        players[1] = new LocalPlayer<>(information.players[1].name);
-                                    });
+                    } else {
-                                },
+                        players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardTicTacToe>(9), "MiniMax AI");
-                                () -> {
+                    }
-                                        ViewWidget c = new TicTacToeTutorialWidget();
+                    if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstTTT()) {
-                                        transitionNext(c);
+                        new ShowEnableTutorialWidget(
-                                        WidgetContainer.setCurrentView(c);
+                                () -> new TicTacToeTutorialWidget(() -> {
-                                        AppSettings.getSettings().setFirstTTT(false);
+                                    gameController = new TicTacToeBitController(players);
-                                    },
+                                    gameController.start();
-                                () -> {
+                                }),
-                                    AppSettings.getSettings().setTutorialFlag(false);
+                                () -> Platform.runLater(() -> {
-                                    Platform.runLater(() -> {
+                                    gameController = new TicTacToeBitController(players);
-                                        new TicTacToeGameThread(information);
+                                    gameController.start();
-                                    });
+                                }),
-                                }
+                                () -> AppSettings.getSettings().setFirstTTT(false)
-                        );
+                        );
-                         transitionNext(a);
+                    } else {
-                         break;
+                        gameController = new TicTacToeBitController(players);
+                        gameController.start();
                     }
-                    new TicTacToeGameThread(information);
                     break;
                 case REVERSI:
+                    boolean swap = AppSettings.getSettings().getSwitchReversi();
+                    if (information.players[0].isHuman) {
+                        players[0] = new LocalPlayer<>(information.players[0].name);
+                    } else {
+                        players[0] = new ArtificialPlayer<>(new RandomAI<BitboardReversi>(), "Random AI");
+                    }
+                    if (information.players[1].isHuman) {
+                        players[1] = new LocalPlayer<>(information.players[1].name);
+                    } else {
+                        players[1] = new ArtificialPlayer<>(new MiniMaxAI<BitboardReversi>(6), "MiniMax");
+                    }
                     if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstReversi()) {
-                        BaseTutorialWidget a = new BaseTutorialWidget(
+                        new ShowEnableTutorialWidget(
-                                "tutorial",
+                                () -> new ReversiTutorialWidget(() -> {
-                                () -> { Platform.runLater(() -> {
+                                    gameController = new ReversiBitController(players, swap);
-                                    AppSettings.getSettings().setFirstReversi(false);
+                                    gameController.start();
-                                    new ReversiGame(information);
+                                }),
-                                });
+                                () -> Platform.runLater(() -> {
-                                },
+                                    gameController = new ReversiBitController(players, swap);
-                                () -> {
+                                    gameController.start();
-                                    Platform.runLater(() -> {
+                                }),
-                                        ViewWidget c = new ReversiTutorialWidget();
+                                () -> AppSettings.getSettings().setFirstReversi(false)
-                                        transitionNext(c);
+                        );
-                                        WidgetContainer.setCurrentView(c);
+                    } else {
-                                        AppSettings.getSettings().setFirstReversi(false);
+                        gameController = new ReversiBitController(players, swap);
-                                    });
+                        gameController.start();
-                                },
-                                () -> {
-                                    Platform.runLater(() -> {
-                                        AppSettings.getSettings().setTutorialFlag(false);
-                                        new ReversiGame(information);
-                                    });
-                                });
-                        transitionNext(a);
-                        break;
                     }
-                    new ReversiGame(information);
                     break;
-                case CONNECT4:
+            }
-                    if (AppSettings.getSettings().getTutorialFlag() && AppSettings.getSettings().getFirstConnect4()) {
+        });
-                        BaseTutorialWidget a = new BaseTutorialWidget(
-                                "tutorial",
-                                () -> { Platform.runLater(() -> {
-                                    AppSettings.getSettings().setFirstConnect4(false);
-                                    new Connect4Game(information);
-                                });
-                                },
-                                () -> {
-                                    Platform.runLater(() -> {
-                                        ViewWidget c = new Connect4TutorialWidget();
-                                        transitionNext(c);
-                                        WidgetContainer.setCurrentView(c);
-                                        AppSettings.getSettings().setFirstConnect4(false);
-                                    });
-                                },
-                                () -> {
-                                    Platform.runLater(() -> {
-                                        AppSettings.getSettings().setTutorialFlag(false);
-                                        new Connect4Game(information);
-                                    });
-                                    });
-                        transitionNext(a);
-                        break;
-                    }
-                    new Connect4Game(information);
-                    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,
+			reversiButton
-			connect4Button
 		));
 	}
 }

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

@@ -1,9 +1,9 @@
 package org.toop.app.widget.view;
 
-import org.toop.app.App;
 import org.toop.app.widget.Primitive;
 import org.toop.app.widget.complex.ViewWidget;
 import javafx.geometry.Pos;
+import org.toop.app.widget.popup.QuitPopup;
 
 public class MainView extends ViewWidget {
 	public MainView() {
@@ -24,7 +24,8 @@ public class MainView extends ViewWidget {
 		});
 
 		var quitButton = Primitive.button("quit", () -> {
-			App.startQuit();
+			var a = new QuitPopup();
+			a.show(Pos.CENTER);
 		});
 
 		add(Pos.CENTER, Primitive.vbox(

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

@@ -74,7 +74,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.MASTERVOLUME))
-					.asyncPostEvent();
+					.postEvent();
 			}
 		);
 
@@ -86,7 +86,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setFxVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.FX))
-					.asyncPostEvent();
+					.postEvent();
 			}
 		);
 
@@ -98,7 +98,7 @@ public class OptionsView extends ViewWidget {
 				AppSettings.getSettings().setMusicVolume(val);
 				new EventFlow()
 					.addPostEvent(new AudioEvents.ChangeVolume(val, VolumeControl.MUSIC))
-					.asyncPostEvent();
+					.postEvent();
 			}
 		);
 
@@ -149,13 +149,22 @@ public class OptionsView extends ViewWidget {
 			"small", "medium", "large"
 		);
 
+        var swapReversiColors = new ToggleWidget(
+                "reversinotswapped", "reversiswapped",
+                AppSettings.getSettings().getSwitchReversi(),
+                swap -> {
+                    AppSettings.getSettings().setSwitchReversi(swap);
+                }
+        );
 
 		return Primitive.vbox(
 			Primitive.header("style"),
 			Primitive.separator(),
 
 			themeWidget.getNode(),
-			layoutWidget.getNode()
+			layoutWidget.getNode(),
+            Primitive.text("reversiswap"),
+            swapReversiColors.getNode()
 		);
 	}
 }

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

@@ -14,14 +14,12 @@ import javafx.scene.control.ListView;
 public final class ServerView extends ViewWidget {
 	private final String user;
 	private final Consumer<String> onPlayerClicked;
-	private final Runnable onDisconnect;
 
 	private final ListView<Button> listView;
 
-	public ServerView(String user, Consumer<String> onPlayerClicked, Runnable onDisconnect) {
+	public ServerView(String user, Consumer<String> onPlayerClicked) {
 		this.user = user;
 		this.onPlayerClicked = onPlayerClicked;
-		this.onDisconnect = onDisconnect;
 
 		this.listView = new ListView<>();
 
@@ -29,7 +27,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,
@@ -40,7 +38,6 @@ public final class ServerView extends ViewWidget {
 		add(Pos.CENTER, playerListSection);
 
 		var disconnectButton = Primitive.button("disconnect", () -> {
-			onDisconnect.run();
 			transitionPrevious();
 		});
 
@@ -52,7 +49,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

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

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

@@ -5,18 +5,16 @@ import org.toop.framework.audio.VolumeControl;
 import org.toop.framework.audio.events.AudioEvents;
 import org.toop.framework.eventbus.EventFlow;
 import org.toop.framework.resource.ResourceManager;
-import org.toop.framework.resource.ResourceMeta;
 import org.toop.framework.resource.resources.SettingsAsset;
 import org.toop.framework.settings.Settings;
 
-import java.io.File;
 import java.util.Locale;
 
 public class AppSettings {
 	private static SettingsAsset settingsAsset;
 
 	public static void applySettings() {
-		settingsAsset = getPath();
+		settingsAsset = getSettingsAsset();
 		if (!settingsAsset.isLoaded()) {
 			settingsAsset.load();
 		}
@@ -27,38 +25,27 @@ public class AppSettings {
 
 		AppContext.setLocale(Locale.of(settingsData.locale));
 		App.setFullscreen(settingsData.fullScreen);
-		new EventFlow()
+
-			.addPostEvent(new AudioEvents.ChangeVolume(settingsData.volume, VolumeControl.MASTERVOLUME))
-			.asyncPostEvent();
-		new EventFlow()
-			.addPostEvent(new AudioEvents.ChangeVolume(settingsData.fxVolume, VolumeControl.FX))
-			.asyncPostEvent();
-		new EventFlow()
-			.addPostEvent(new AudioEvents.ChangeVolume(settingsData.musicVolume, VolumeControl.MUSIC))
-			.asyncPostEvent();
 		App.setStyle(settingsAsset.getTheme(), settingsAsset.getLayoutSize());
 	}
 
-	public static SettingsAsset getPath() {
+	public static void applyMusicVolumeSettings() {
+		Settings settingsData = settingsAsset.getContent();
+
+		new EventFlow()
+				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.volume, VolumeControl.MASTERVOLUME))
+				.postEvent();
+		new EventFlow()
+				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.fxVolume, VolumeControl.FX))
+				.postEvent();
+		new EventFlow()
+				.addPostEvent(new AudioEvents.ChangeVolume(settingsData.musicVolume, VolumeControl.MUSIC))
+				.postEvent();
+	}
+
+	public static SettingsAsset getSettingsAsset() {
 		if (settingsAsset == null) {
-			String os = System.getProperty("os.name").toLowerCase();
+			settingsAsset = SettingsAsset.getPath();
-			String basePath;
-
-			if (os.contains("win")) {
-				basePath = System.getenv("APPDATA");
-				if (basePath == null) {
-					basePath = System.getProperty("user.home");
-				}
-			} else if (os.contains("mac")) {
-				basePath = System.getProperty("user.home") + "/Library/Application Support";
-			} else {
-				basePath = System.getProperty("user.home") + "/.config";
-			}
-
-			File settingsFile =
-				new File(basePath + File.separator + "ISY1" + File.separator + "settings.json");
-//            this.settingsAsset = new SettingsAsset(settingsFile);
-			ResourceManager.addAsset(new ResourceMeta<>("settings.json", new SettingsAsset(settingsFile)));
 		}
 		return ResourceManager.get("settings.json");
 	}
@@ -104,5 +91,6 @@ public class AppSettings {
         settingsAsset.setMusicVolume(15);
         settingsAsset.setTutorialFlag(true);
         settingsAsset.setLayoutSize("medium");
+        settingsAsset.setSwitchReversi(false);
     }
 }

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

@@ -83,6 +83,16 @@ 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
+turnof=\u062F\u0648\u0631\u0647
+zwartepiet=\u0633\u0647\u0644: Zwarte Piet
+sinterklaas=\u0645\u062a\u0648\u0633\u0637: Sint R. Klaas
+santa=\u0635\u0639\u0628: Santa
+reversiswapped=\u0645\u0628\u062F\u0651\u064E\u0644
+reversinotswapped=\u063A\u064A\u0631\u0020\u0645\u0628\u062F\u0651\u064E\u0644
+reversiswap=\u0647\u0644\u0020\u062A\u0631\u064A\u062F\u0020\u062A\u0628\u062F\u064A\u0644\u0020\u0623\u0644\u0648\u0627\u0646\u0020\u0627\u0644\u0631\u064A\u0641\u064E\u0631\u0633\u064A\u061F\u0020\u0645\u062D\u0644\u064A\u0020\u0641\u0642\u0637\u002E
+
 
 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,15 @@ 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
+turnof=ist dran
+zwartepiet=Leicht: Zwarte Piet
+sinterklaas=Mittel: Sint R. Klaas
+santa=Schwer: Santa
+reversiswapped=Getauscht
+reversinotswapped=Nicht getauscht
+reversiswap=M\u00F6chten Sie die Reversi-Farben tauschen? Nur lokal.
 
 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
@@ -22,6 +24,7 @@ error=Error
 exit=Exit
 forfeit=Forfeit
 fullscreen=Fullscreen
+game=REPLACE ME
 game-over=Game Over
 general=General
 high-contrast=High contrast
@@ -84,7 +87,15 @@ reversi2=Clicking on a dot will flip all the moves between where you place the d
 reversi3=Your turn may be skipped if there is no legal move. This will let your opponent play again until you get an opportunity at a legal move.
 reversi4=The player who wins at the end of the game is the one who has the most pieces on the board.
 tutorialstring=Tutorial
-
+startgame=Start game!
+goback=Go back
+turnof='s turn
+zwartepiet=Easy: Zwarte Piet
+sinterklaas=Medium: Sint R. Klaas
+santa=Hard:Santa
+reversiswapped=Swapped
+reversinotswapped=Not Swapped
+reversiswap=Do you want to swap the Reversi colors? Local only.
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabic)
 chinese=\u4e2d\u6587 (Chinese)

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

@@ -84,7 +84,15 @@ 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
+turnof=le toca
+zwartepiet=F\u00e1cil: Zwarte Piet
+sinterklaas=Medio: Sint R. Klaas
+santa=Dif\u00edcil: Santa
+reversiswapped=Cambiado
+reversinotswapped=No cambiado
+reversiswap=\u00BFDeseas intercambiar los colores de Reversi? Solo local.
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Ar\u00e1bigo)
 chinese=\u4e2d\u6587 (Chino)

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

@@ -84,6 +84,15 @@ 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
+turnof=\u00E0 son tour
+zwartepiet=Facile: Zwarte Piet
+sinterklaas=Moyen : Sint R. Klaas
+santa=Difficile: Santa
+reversiswapped=\u00C9chang\u00E9
+reversinotswapped=Non \u00E9chang\u00E9
+reversiswap=Voulez-vous \u00E9changer les couleurs de Reversi ? Local uniquement.
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabe)
 chinese=\u4e2d\u6587 (Chinois)

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

@@ -84,6 +84,15 @@ 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
+turnof=\u0915\u0940 \u092C\u093E\u0930\u0940
+zwartepiet=\u0905\u0938\u093e\u0928: Zwarte Piet
+sinterklaas=\u092e\u0927\u094d\u092f\u092e: Sint R. Klaas
+santa=\u0915\u0924\u093f\u0928: Santa
+reversiswapped=\u092C\u0926\u0932\u093E\u0020\u0939\u0941\u0906
+reversinotswapped=\u0928\u0939\u0940\u0902\u0020\u092C\u0926\u0932\u093E\u0020\u0939\u0941\u0906
+reversiswap=\u0915\u094D\u092F\u093E\u0020\u0906\u092A\u0020\u0930\u093F\u0935\u0930\u094D\u0938\u0940\u0020\u0915\u0947\u0020\u0930\u0902\u0917\u0020\u092C\u0926\u0932\u0928\u093E\u0020\u091A\u093E\u0939\u0924\u0947\u0020\u0939\u0948\u0902?\u0020\u0915\u0947\u0935\u0932\u0020\u0938\u094D\u0925\u093E\u0928\u0940\u092F\u002E
 
 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,15 @@ 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
+turnof=\u00E8 il suo turno
+zwartepiet=Facile: Zwarte Piet
+sinterklaas=Medio: Sint R. Klaas
+santa=Difficile: Santa
+reversiswapped=Scambiato
+reversinotswapped=Non scambiato
+reversiswap=Vuoi scambiare i colori di Reversi? Solo locale.
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabo)
 chinese=\u4e2d\u6587 (Cinese)

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

@@ -83,6 +83,16 @@ 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
+turnof=\u306E\u756A
+zwartepiet=\u7c21\u5358: Zwarte Piet
+sinterklaas=\u4e2d\u7d1a: Sint R. Klaas
+santa=\u96e3\u3057\u3044: Santa
+reversiswapped=\u5165\u308C\u66FF\u3048\u6E08\u307F
+reversinotswapped=\u672A\u5165\u308C\u66FF\u3048
+reversiswap=\u30EA\u30D0\u30FC\u30B7\u306E\u8272\u3092\u5165\u308C\u66FF\u3048\u307E\u3059\u304B?\u0020\u30ED\u30FC\u30AB\u30EB\u306E\u307F\u3067\u3059\u002E
+
 
 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,15 @@ 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
+turnof=\uC758 \uCC28\uB840
+zwartepiet=\uc218\uc601: Zwarte Piet
+sinterklaas=\ubcf4\ud1b5: Sint R. Klaas
+santa=\uc5d0\uc18c: Santa
+reversiswapped=\uAD50\uCCB4\uB428
+reversinotswapped=\uAD50\uCCB4\uB418\uC9C0 \uC54A\uC74C
+reversiswap=\uB9AC\uBC84\uC2DC \uC0C9\uC0C1\uC744 \uBC14\uAFB8\uC2DC\uACA0\uC2B5\uB2C8\uAE4C?\u0020\uB85C\uCEEC \uC804\uC6A9\u0020\uC785\uB2C8\uB2E4\u002E
 
 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,15 @@ 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
+turnof=is aan de beurt
+zwartepiet=Makkelijk: Zwarte Piet
+sinterklaas=Gemiddeld: Sint R. Klaas
+santa=Moeilijk: Santa
+reversiswapped=Gewisseld
+reversinotswapped=Niet gewisseld
+reversiswap=Wil je de Reversi-kleuren wisselen? Alleen lokaal.
 
 arabic=\u0627\u0644\u0639\u0631\u0628\u064a\u0629 (Arabisch)
 chinese=\u4e2d\u6587 (Chinees)

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

@@ -83,6 +83,15 @@ 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
+turnof=\u0445\u043E\u0434\u0438\u0442
+zwartepiet=\u041b\u0435\u0433\u043a\u043e: Zwarte Piet
+sinterklaas=\u0421\u0440\u0435\u0434\u043d\u0438\u0439: Sint R. Klaas
+santa=\u0421\u043b\u043e\u0436\u043d\u043e: Santa
+reversiswapped=\u041F\u043E\u043C\u0435\u043D\u044F\u043D\u043E
+reversinotswapped=\u041D\u0435 \u043F\u043E\u043C\u0435\u043D\u044F\u043D\u043E
+reversiswap=\u0425\u043E\u0442\u0438\u0442\u0435 \u043F\u043E\u043C\u0435\u043D\u044F\u0442\u044C \u0446\u0432\u0435\u0442\u0430 \u0420\u0435\u0432\u0435\u0440\u0441\u0438?\u0020\u0422\u043E\u043B\u044C\u043A\u043E \u043B\u043E\u043A\u0430\u043B\u044C\u043D\u043E\u002E
 
 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,15 @@ 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
+turnof=\u7684\u56DE\u5408
+zwartepiet=\u7b80\u5355: Zwarte Piet
+sinterklaas=\u4e2d\u7b49: Sint R. Klaas
+santa=\u56f0\u96be: Santa
+reversiswapped=\u5DF2\u4EA4\u6362
+reversinotswapped=\u672A\u4EA4\u6362
+reversiswap=\u662F\u5426\u8981\u4EA4\u6362\u9ED1\u767D\u68CB\u7684\u989C\u8272\uFF1F\u4EC5\u9650\u672C\u5730\u002E
 
 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;
@@ -155,7 +166,7 @@
 	-fx-effect: dropshadow(gaussian, #88cc8899, 5, 0, 0, 1);
 }
 
-.my-turn {
+.text.my-turn {
 	-fx-fill: #e05656;
 	-fx-font-weight: bold;
 }

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

@@ -13,68 +13,77 @@
 }
 
 .song-display {
-    -fx-padding: 8 12 8 12;
+	-fx-padding: 8 12 8 12;
-    -fx-spacing: 6px;
+	-fx-spacing: 6px;
-    -fx-alignment: center;
+	-fx-alignment: center;
-    -fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.5), 6, 0.5, 0, 2);
+	-fx-min-width: 220px;
-    -fx-min-width: 220px;
+	-fx-max-width: 260px;
-    -fx-max-width: 260px;
 }
 
 .song-title {
-    -fx-font-size: 14px;
+	-fx-font-size: 14px;
-    -fx-fill: white;
+	-fx-fill: white;
 }
 
 .progress-bar {
-    -fx-pref-width: 200px;
+	-fx-inner-background-color: black;
-    -fx-accent: red;
+	-fx-pref-width: 200px;
+	-fx-accent: red;
 }
 
 .progress-bar > .track {
-    -fx-background-radius: 30;
+	-fx-background-radius: 30;
 }
 
 .progress-bar > .bar {
-    -fx-background-radius: 30px;
+	-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-font-size: 11px;
-    -fx-fill: white;
+	-fx-fill: white;
 }
 
 .skip-button {
-    -fx-background-color: transparent;
+	-fx-background-color: transparent;
-    -fx-background-radius: 0;
+	-fx-background-radius: 0;
- 	-fx-cursor: hand;
+	-fx-cursor: hand;
- 	-fx-text-fill: white;
+}
- 	}
 
-.skip-button .text {
+.skip-button > .text {
-    -fx-fill: white;
+	-fx-fill: white;
 }
 
 .pause-button {
-    -fx-background-color: transparent;
+	-fx-background-color: transparent;
-    -fx-background-radius: 0;
+	-fx-background-radius: 0;
- 	-fx-cursor: hand;
+	-fx-cursor: hand;
- 	-fx-text-fill: white;
+}
- 	}
 
-.pause-button .text {
+.pause-button > .text {
-    -fx-fill: white;
+	-fx-fill: white;
 }
 
 .previous-button {
-    -fx-background-color: transparent;
+	-fx-background-color: transparent;
-    -fx-background-radius: 0;
+	-fx-background-radius: 0;
- 	-fx-cursor: hand;
+	-fx-cursor: hand;
- 	-fx-text-fill: white;
+}
- 	}
 
-.previous-button .text {
+.previous-button > .text {
-    -fx-fill: white;
+	-fx-fill: white;
 }
 
 .button {
@@ -155,7 +164,7 @@
 	-fx-effect: dropshadow(gaussian, #70e070cc, 6, 0, 0, 2);
 }
 
-.my-turn {
+.text.my-turn {
 	-fx-fill: #ff4b4b;
 	-fx-font-weight: bold;
 }

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

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

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

@@ -13,69 +13,79 @@
 }
 
 .song-display {
-    -fx-padding: 8 12 8 12;
+	-fx-padding: 8 12 8 12;
-    -fx-spacing: 6px;
+	-fx-spacing: 6px;
-    -fx-alignment: center;
+	-fx-alignment: center;
-    -fx-effect: dropshadow(gaussian, rgba(0, 0, 0, 0.5), 6, 0.5, 0, 2);
+	-fx-min-width: 220px;
-    -fx-min-width: 220px;
+	-fx-max-width: 260px;
-    -fx-max-width: 260px;
 }
 
 .song-title {
-    -fx-font-size: 14px;
+	-fx-font-size: 14px;
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .progress-bar {
-    -fx-inner-background-color: black;
+	-fx-inner-background-color: black;
-    -fx-pref-width: 200px;
+	-fx-pref-width: 200px;
-    -fx-accent: red;
+	-fx-accent: red;
 }
 
 .progress-bar > .track {
-    -fx-background-radius: 30;
+	-fx-background-radius: 30;
 }
 
 .progress-bar > .bar {
-    -fx-background-radius: 30px;
+	-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-font-size: 11px;
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .skip-button {
-    -fx-background-color: transparent;
+	-fx-background-color: transparent;
-    -fx-background-radius: 0;
+	-fx-background-radius: 0;
- 	-fx-cursor: hand;
+	-fx-cursor: hand;
- 	-fx-text-fill: black;
+	-fx-effect: null;
- 	}
+}
 
 .skip-button .text {
-    -fx-fill: black;
 }
 
 .pause-button {
-    -fx-background-color: transparent;
+	-fx-background-color: transparent;
-    -fx-background-radius: 0;
+	-fx-background-radius: 0;
- 	-fx-cursor: hand;
+	-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-color: transparent;
-    -fx-background-radius: 0;
+	-fx-background-radius: 0;
- 	-fx-cursor: hand;
+	-fx-cursor: hand;
- 	-fx-text-fill: black;
+	-fx-effect: null;
- 	}
+}
 
 .previous-button .text {
-    -fx-fill: black;
+	-fx-effect: null;
 }
 
 .button {
@@ -156,7 +166,7 @@
 	-fx-effect: dropshadow(gaussian, #aad3aa99, 4, 0, 0, 1);
 }
 
-.my-turn {
+.text.my-turn {
 	-fx-fill: #d14b4b;
 	-fx-font-weight: bold;
 }

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

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

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

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

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

@@ -5,37 +5,39 @@ import org.toop.framework.audio.interfaces.MusicManager;
 import org.toop.framework.audio.interfaces.SoundEffectManager;
 import org.toop.framework.audio.interfaces.VolumeManager;
 import org.toop.framework.eventbus.EventFlow;
-import org.toop.framework.eventbus.GlobalEventBus;
+import org.toop.framework.eventbus.bus.EventBus;
 import org.toop.framework.resource.types.AudioResource;
 
 public class AudioEventListener<T extends AudioResource, K extends AudioResource> {
+    private final EventBus eventBus;
     private final MusicManager<T> musicManager;
     private final SoundEffectManager<K> soundEffectManager;
     private final VolumeManager audioVolumeManager;
 
     public AudioEventListener(
+            EventBus eventBus,
             MusicManager<T> musicManager,
             SoundEffectManager<K> soundEffectManager,
             VolumeManager audioVolumeManager
     ) {
+        this.eventBus = eventBus;
         this.musicManager = musicManager;
         this.soundEffectManager = soundEffectManager;
         this.audioVolumeManager = audioVolumeManager;
     }
 
     public AudioEventListener<?, ?> initListeners(String buttonSoundToPlay) {
-        new EventFlow()
+        new EventFlow(eventBus)
-                .listen(this::handleStopMusicManager)
+                .listen(AudioEvents.StopAudioManager.class, this::handleStopMusicManager, false)
-                .listen(this::handlePlaySound)
+                .listen(AudioEvents.PlayEffect.class, this::handlePlaySound, false)
-                .listen(this::handleSkipSong)
+                .listen(AudioEvents.SkipMusic.class, this::handleSkipSong, false)
-                .listen(this::handlePauseSong)
+                .listen(AudioEvents.PauseMusic.class, this::handlePauseSong, false)
-                .listen(this::handlePreviousSong)
+                .listen(AudioEvents.PreviousMusic.class, this::handlePreviousSong, false)
-                .listen(this::handleStopSound)
+                .listen(AudioEvents.StopEffect.class, this::handleStopSound, false)
-                .listen(this::handleMusicStart)
+                .listen(AudioEvents.StartBackgroundMusic.class, this::handleMusicStart, false)
-                .listen(this::handleVolumeChange)
+                .listen(AudioEvents.ChangeVolume.class, this::handleVolumeChange, false)
-                .listen(this::handleGetVolume)
+                .listen(AudioEvents.GetVolume.class, this::handleGetVolume,false)
-                .listen(AudioEvents.ClickButton.class, _ ->
+                .listen(AudioEvents.ClickButton.class, _ -> soundEffectManager.play(buttonSoundToPlay, false), false);
-                        soundEffectManager.play(buttonSoundToPlay, false));
 
         return this;
     }
@@ -74,7 +76,7 @@ public class AudioEventListener<T extends AudioResource, K extends AudioResource
     }
 
     private void handleGetVolume(AudioEvents.GetVolume event) {
-        GlobalEventBus.postAsync(new AudioEvents.GetVolumeResponse(
+        eventBus.post(new AudioEvents.GetVolumeResponse(
                 audioVolumeManager.getVolume(event.controlType()),
                 event.identifier()));
     }

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

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

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

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

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

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

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

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

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

@@ -13,10 +13,14 @@ import org.toop.framework.SnowflakeGenerator;
 import org.toop.framework.eventbus.events.EventType;
 import org.toop.framework.eventbus.events.ResponseToUniqueEvent;
 import org.toop.framework.eventbus.events.UniqueEvent;
+import org.toop.framework.eventbus.bus.EventBus;
+import org.toop.framework.eventbus.subscriber.DefaultNamedSubscriber;
+import org.toop.framework.eventbus.subscriber.NamedSubscriber;
+import org.toop.framework.eventbus.subscriber.Subscriber;
 
 /**
  * EventFlow is a utility class for creating, posting, and optionally subscribing to events in a
- * type-safe and chainable manner. It is designed to work with the {@link GlobalEventBus}.
+ * type-safe and chainable manner. It is designed to work with the {@link EventBus}.
  *
  * <p>This class supports automatic UUID assignment for {@link UniqueEvent} events, and
  * allows filtering subscribers so they only respond to events with a specific UUID. All
@@ -31,6 +35,8 @@ public class EventFlow {
     /** Cache of constructor handles for event classes to avoid repeated reflection lookups. */
     private static final Map<Class<?>, MethodHandle> CONSTRUCTOR_CACHE = new ConcurrentHashMap<>();
 
+    private final EventBus eventBus;
+
     /** Automatically assigned UUID for {@link UniqueEvent} events. */
     private long eventSnowflake = -1;
 
@@ -38,24 +44,29 @@ public class EventFlow {
     private EventType event = null;
 
     /** The listener returned by GlobalEventBus subscription. Used for unsubscription. */
-    private final List<ListenerHandler> listeners = new ArrayList<>();
+    private final List<NamedSubscriber<?>> listeners = new ArrayList<>();
 
     /** Holds the results returned from the subscribed event, if any. */
     private Map<String, ?> result = null;
 
     /** Empty constructor (event must be added via {@link #addPostEvent(Class, Object...)}). */
-    public EventFlow() {}
+    public EventFlow(EventBus eventBus) {
-
+        this.eventBus = eventBus;
-    public EventFlow addPostEvent(EventType event) {
-        this.event = event;
-        return this;
     }
 
-    public EventFlow addPostEvent(Supplier<? extends EventType> eventSupplier) {
+    public EventFlow() {
-        this.event = eventSupplier.get();
+        this.eventBus = GlobalEventBus.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,155 +109,403 @@ 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) {
+     * Add an event that will be triggered when {@link #postEvent()} or {@link #asyncPostEvent()} is called.
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
+     *
-        listenerHolder[0] =
+     * @param event The event to be posted.
-                new ListenerHandler(
+     * @return {@link #EventFlow}
-                        GlobalEventBus.subscribe(
+     *
-                                eventClass,
+     */
-                                event -> {
+    public EventFlow addPostEvent(EventType event) {
-                                    if (event.getIdentifier() != this.eventSnowflake) return;
+        this.event = event;
-
-                                    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]);
         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(String.valueOf(id));
+
+            this.result = eventClass.result();
+        };
+
+        var subscriber = new DefaultNamedSubscriber<>(
+                name,
+                event,
+                newAction
+        );
+
+        eventBus.subscribe(subscriber);
+        this.listeners.add(subscriber);
+        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) {
+            Consumer<TT> action, boolean unsubscribeAfterSuccess, String name) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
+
-        listenerHolder[0] =
+        final long id = SnowflakeGenerator.nextId();
-                new ListenerHandler(
+
-                        GlobalEventBus.subscribe(
+        Consumer<TT> newAction = event -> {
-                                event -> {
+            if (!(event instanceof UniqueEvent uuidEvent)) return;
-                                    if (!(event instanceof UniqueEvent uuidEvent)) return;
+            if (uuidEvent.getIdentifier() == this.eventSnowflake) {
-                                    if (uuidEvent.getIdentifier() == this.eventSnowflake) {
+                try {
-                                        try {
+                    TT typedEvent = (TT) uuidEvent;
-                                            TT typedEvent = (TT) uuidEvent;
+                    action.accept(typedEvent);
-                                            action.accept(typedEvent);
+
-                                            if (unsubscribeAfterSuccess
+                    if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
-                                                    && listenerHolder[0] != null) {
+
-                                                GlobalEventBus.unsubscribe(listenerHolder[0]);
+                    this.result = typedEvent.result();
-                                                this.listeners.remove(listenerHolder[0]);
+                } catch (ClassCastException _) {
-                                            }
+                    throw new ClassCastException(
-                                            this.result = typedEvent.result();
+                            "Cannot cast "
-                                        } catch (ClassCastException _) {
+                                    + event.getClass().getName()
-                                            throw new ClassCastException(
+                                    + " to UniqueEvent");
-                                                    "Cannot cast "
+                }
-                                                            + event.getClass().getName()
+            }
-                                                            + " to UniqueEvent");
+        };
-                                        }
+
-                                    }
+        var listener = new DefaultNamedSubscriber<>(
-                                }));
+                name,
-        this.listeners.add(listenerHolder[0]);
+                (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0],
+                newAction
+        );
+
+        eventBus.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) {
+            Class<TT> event, Consumer<TT> action, boolean unsubscribeAfterSuccess, String name) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
-        listenerHolder[0] =
-                new ListenerHandler(
-                        GlobalEventBus.subscribe(
-                                eventClass,
-                                event -> {
-                                    action.accept(event);
 
-                                    if (unsubscribeAfterSuccess && listenerHolder[0] != null) {
+        long id = SnowflakeGenerator.nextId();
-                                        GlobalEventBus.unsubscribe(listenerHolder[0]);
+
-                                        this.listeners.remove(listenerHolder[0]);
+        Consumer<TT> newAction = eventc -> {
-                                    }
+            action.accept(eventc);
-                                }));
+
-        this.listeners.add(listenerHolder[0]);
+            if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
+        };
+
+        var listener = new DefaultNamedSubscriber<>(
+                        name,
+                        event,
+                        newAction
+                );
+
+        eventBus.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) {
+            Consumer<TT> action, boolean unsubscribeAfterSuccess, String name) {
-        ListenerHandler[] listenerHolder = new ListenerHandler[1];
+        long id = SnowflakeGenerator.nextId();
-        listenerHolder[0] =
+
-                new ListenerHandler(
+        Class<TT> eventClass = (Class<TT>) action.getClass().getDeclaredMethods()[0].getParameterTypes()[0];
-                        GlobalEventBus.subscribe(
+
-                                event -> {
+        Consumer<TT> newAction = event -> {
-                                    if (!(event instanceof EventType nonUuidEvent)) return;
+            if (!(event instanceof EventType nonUuidEvent)) return;
-                                    try {
+            try {
-                                        TT typedEvent = (TT) nonUuidEvent;
+                TT typedEvent = (TT) nonUuidEvent;
-                                        action.accept(typedEvent);
+                action.accept(typedEvent);
-                                        if (unsubscribeAfterSuccess && listenerHolder[0] != null) {
+                if (unsubscribeAfterSuccess) unsubscribe(String.valueOf(id));
-                                            GlobalEventBus.unsubscribe(listenerHolder[0]);
+            } catch (ClassCastException _) {
-                                            this.listeners.remove(listenerHolder[0]);
+                throw new ClassCastException(
-                                        }
+                        "Cannot cast "
-                                    } catch (ClassCastException _) {
+                                + event.getClass().getName()
-                                        throw new ClassCastException(
+                                + " to UniqueEvent");
-                                                "Cannot cast "
+            }
-                                                        + event.getClass().getName()
+        };
-                                                        + " to UniqueEvent");
+
-                                    }
+        var listener = new DefaultNamedSubscriber<>(
-                                }));
+                name,
-        this.listeners.add(listenerHolder[0]);
+                eventClass,
+                newAction
+        );
+
+        eventBus.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);
+        eventBus.post(this.event);
         return this;
     }
 
-    /** Post asynchronously */
+    /**
+     * Posts the event added through {@link #addPostEvent} asynchronously.
+     *
+     * @deprecated use {@link #postEvent()} instead.
+     */
+    @Deprecated
     public EventFlow asyncPostEvent() {
-        GlobalEventBus.postAsync(this.event);
+        eventBus.post(this.event);
         return this;
     }
 
+    /**
+     *
+     * Unsubscribe from an event.
+     *
+     * @param action The listener object to remove and unsubscribe.
+     */
+    public void unsubscribe(Consumer<?> action) {
+        this.listeners.removeIf(handler -> {
+            if (handler.handler().equals(action)) {
+                eventBus.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.id().equals(name)) {
+                eventBus.unsubscribe(handler);
+                return true;
+            }
+            return false;
+        });
+    }
+
+    /**
+     * Unsubscribe all events.
+     */
+    public void unsubscribeAll() {
+        listeners.removeIf(handler -> {
+            eventBus.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;
     }
 
-    public ListenerHandler[] getListeners() {
+    /**
-        return listeners.toArray(new ListenerHandler[0]);
+     *
+     * Returns a copy of the list of listeners.
+     *
+     * @return Copy of the list of listeners.
+     */
+    public Subscriber<?>[] getListeners() {
+        return listeners.toArray(new Subscriber[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

@@ -1,185 +1,46 @@
 package org.toop.framework.eventbus;
 
-import com.lmax.disruptor.*;
+import org.apache.logging.log4j.LogManager;
-import com.lmax.disruptor.dsl.Disruptor;
+import org.toop.framework.eventbus.bus.DisruptorEventBus;
-import com.lmax.disruptor.dsl.ProducerType;
+import org.toop.framework.eventbus.bus.EventBus;
-import java.util.Map;
-import java.util.concurrent.*;
-import java.util.function.Consumer;
 import org.toop.framework.eventbus.events.EventType;
-import org.toop.framework.eventbus.events.UniqueEvent;
+import org.toop.framework.eventbus.store.DefaultSubscriberStore;
+import org.toop.framework.eventbus.subscriber.Subscriber;
 
-/**
+public class GlobalEventBus implements EventBus {
- * GlobalEventBus backed by the LMAX Disruptor for ultra-low latency, high-throughput event
+    private static final EventBus INSTANCE = new DisruptorEventBus(
- * publishing.
+            LogManager.getLogger(DisruptorEventBus.class),
- */
+            new DefaultSubscriberStore()
-public final class GlobalEventBus {
+    );
 
-    /** Map of event class to type-specific listeners. */
-    private static final Map<Class<?>, CopyOnWriteArrayList<Consumer<? super EventType>>>
-            LISTENERS = new ConcurrentHashMap<>();
-
-    /** Map of event class to Snowflake-ID-specific listeners. */
-    private static final Map<
-                    Class<?>, ConcurrentHashMap<Long, Consumer<? extends UniqueEvent>>>
-            UUID_LISTENERS = new ConcurrentHashMap<>();
-
-    /** Disruptor ring buffer size (must be power of two). */
-    private static final int RING_BUFFER_SIZE = 1024 * 64;
-
-    /** Disruptor instance. */
-    private static final Disruptor<EventHolder> DISRUPTOR;
-
-    /** Ring buffer used for publishing events. */
-    private static final RingBuffer<EventHolder> RING_BUFFER;
-
-    static {
-        ThreadFactory threadFactory =
-                r -> {
-                    Thread t = new Thread(r, "EventBus-Disruptor");
-                    t.setDaemon(true);
-                    return t;
-                };
-
-        DISRUPTOR =
-                new Disruptor<>(
-                        EventHolder::new,
-                        RING_BUFFER_SIZE,
-                        threadFactory,
-                        ProducerType.MULTI,
-                        new BusySpinWaitStrategy());
-
-        // Single consumer that dispatches to subscribers
-        DISRUPTOR.handleEventsWith(
-                (holder, seq, endOfBatch) -> {
-                    if (holder.event != null) {
-                        dispatchEvent(holder.event);
-                        holder.event = null;
-                    }
-                });
-
-        DISRUPTOR.start();
-        RING_BUFFER = DISRUPTOR.getRingBuffer();
-    }
-
-    /** Prevent instantiation. */
     private GlobalEventBus() {}
 
-    /** Wrapper used inside the ring buffer. */
+    public static EventBus get() {
-    private static class EventHolder {
+        return INSTANCE;
-        EventType event;
     }
 
-    // ------------------------------------------------------------------------
+    @Override
-    // Subscription
+    public void subscribe(Subscriber<? extends EventType> listener) {
-    // ------------------------------------------------------------------------
+        INSTANCE.subscribe(listener);
-    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) {
+    @Override
-        Consumer<? super EventType> wrapper = event -> listener.accept(event);
+    public void unsubscribe(Subscriber<? extends EventType> listener) {
-        LISTENERS.computeIfAbsent(Object.class, _ -> new CopyOnWriteArrayList<>()).add(wrapper);
+        INSTANCE.unsubscribe(listener);
-        return wrapper;
     }
 
-    public static <T extends UniqueEvent> void subscribeById(
+    @Override
-            Class<T> eventClass, long eventId, Consumer<T> listener) {
+    public <T extends EventType> void post(T event) {
-        UUID_LISTENERS
+        INSTANCE.post(event);
-                .computeIfAbsent(eventClass, _ -> new ConcurrentHashMap<>())
-                .put(eventId, listener);
     }
 
-    public static void unsubscribe(Object listener) {
+    @Override
-        LISTENERS.values().forEach(list -> list.remove(listener));
+    public void shutdown() {
+        INSTANCE.shutdown();
     }
 
-    public static <T extends UniqueEvent> void unsubscribeById(
+    @Override
-            Class<T> eventClass, long eventId) {
+    public void reset() {
-        Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(eventClass);
+        INSTANCE.reset();
-        if (map != null) map.remove(eventId);
-    }
-
-    // ------------------------------------------------------------------------
-    // Posting
-    // ------------------------------------------------------------------------
-    public static <T extends EventType> void post(T event) {
-        dispatchEvent(event); // synchronous
-    }
-
-    public static <T extends EventType> void postAsync(T event) {
-        long seq = RING_BUFFER.next();
-        try {
-            EventHolder holder = RING_BUFFER.get(seq);
-            holder.event = event;
-        } finally {
-            RING_BUFFER.publish(seq);
-        }
-    }
-
-    @SuppressWarnings("unchecked")
-    private static void dispatchEvent(EventType event) {
-        Class<?> clazz = event.getClass();
-
-        // class-specific listeners
-        CopyOnWriteArrayList<Consumer<? super EventType>> classListeners = LISTENERS.get(clazz);
-        if (classListeners != null) {
-            for (Consumer<? super EventType> listener : classListeners) {
-                try {
-                    listener.accept(event);
-                } catch (Throwable e) {
-//                    e.printStackTrace();
-                }
-            }
-        }
-
-        // generic listeners
-        CopyOnWriteArrayList<Consumer<? super EventType>> genericListeners =
-                LISTENERS.get(Object.class);
-        if (genericListeners != null) {
-            for (Consumer<? super EventType> listener : genericListeners) {
-                try {
-                    listener.accept(event);
-                } catch (Throwable e) {
-                    // e.printStackTrace();
-                }
-            }
-        }
-
-        // snowflake listeners
-        if (event instanceof UniqueEvent snowflakeEvent) {
-            Map<Long, Consumer<? extends UniqueEvent>> map = UUID_LISTENERS.get(clazz);
-            if (map != null) {
-                Consumer<UniqueEvent> listener =
-                        (Consumer<UniqueEvent>) map.remove(snowflakeEvent.getIdentifier());
-                if (listener != null) {
-                    try {
-                        listener.accept(snowflakeEvent);
-                    } catch (Throwable ignored) {
-                    }
-                }
-            }
-        }
-    }
-
-    // ------------------------------------------------------------------------
-    // Lifecycle
-    // ------------------------------------------------------------------------
-    public static void shutdown() {
-        DISRUPTOR.shutdown();
-        LISTENERS.clear();
-        UUID_LISTENERS.clear();
-    }
-
-    public static void reset() {
-        LISTENERS.clear();
-        UUID_LISTENERS.clear();
     }
 }

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

@@ -1,25 +0,0 @@
-package org.toop.framework.eventbus;
-
-public class ListenerHandler {
-    private Object listener;
-
-    //    private boolean unsubscribeAfterSuccess = true;
-
-    //    public ListenerHandler(Object listener, boolean unsubAfterSuccess) {
-    //        this.listener = listener;
-    //        this.unsubscribeAfterSuccess = unsubAfterSuccess;
-    //    }
-
-    public ListenerHandler(Object listener) {
-        this.listener = listener;
-    }
-
-    public Object getListener() {
-        return this.listener;
-    }
-
-    //    public boolean isUnsubscribeAfterSuccess() {
-    //        return this.unsubscribeAfterSuccess;
-    //    }
-
-}

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

@@ -0,0 +1,53 @@
+package org.toop.framework.eventbus.bus;
+
+import org.apache.logging.log4j.Logger;
+import org.toop.framework.eventbus.events.EventType;
+import org.toop.framework.eventbus.store.SubscriberStore;
+import org.toop.framework.eventbus.subscriber.Subscriber;
+
+import java.util.function.Consumer;
+
+public class DefaultEventBus implements EventBus {
+    private final Logger logger;
+    private final SubscriberStore eventsHolder;
+
+    public DefaultEventBus(Logger logger, SubscriberStore eventsHolder) {
+        this.logger = logger;
+        this.eventsHolder = eventsHolder;
+    }
+
+    @Override
+    public void subscribe(Subscriber<? extends EventType> subscriber) {
+        eventsHolder.add(subscriber);
+    }
+
+    @Override
+    public void unsubscribe(Subscriber<? extends EventType> subscriber) {
+        eventsHolder.remove(subscriber);
+    }
+
+    @Override
+    @SuppressWarnings("unchecked")
+    public <T extends EventType> void post(T event) {
+        Class<T> eventType = (Class<T>) event.getClass();
+        var subs = eventsHolder.get(eventType);
+        if (subs != null) {
+            for (Subscriber<?> subscriber : subs) {
+                Class<T> eventClass = (Class<T>) subscriber.event();
+                Consumer<EventType> action = (Consumer<EventType>) subscriber.handler();
+
+                action.accept((EventType) eventClass.cast(event));
+            }
+        }
+    }
+
+    @Override
+    public void shutdown() {
+        eventsHolder.reset();
+    }
+
+    @Override
+    public void reset() {
+        eventsHolder.reset();
+    }
+}

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

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