diff --git a/.idea/dictionaries/project.xml b/.idea/dictionaries/project.xml
index 342b6a3..b9de90b 100644
--- a/.idea/dictionaries/project.xml
+++ b/.idea/dictionaries/project.xml
@@ -2,6 +2,7 @@
   <dictionary name="project">
     <words>
       <w>aosp</w>
+      <w>vmoptions</w>
     </words>
   </dictionary>
 </component>
\ No newline at end of file
diff --git a/pom.xml b/pom.xml
index fe48d59..2489551 100644
--- a/pom.xml
+++ b/pom.xml
@@ -135,9 +135,9 @@
 						<!-- apply a specific flavor of google-java-format and reflow long strings -->
 						<googleJavaFormat>
 							<version>1.28.0</version>
-							<style>AOSP</style>
+							<style>AOSP</style> <!-- GOOGLE (2 indents), AOSP (4 indents) -->
 							<reflowLongStrings>true</reflowLongStrings>
-							<formatJavadoc>false</formatJavadoc>
+							<formatJavadoc>true</formatJavadoc>
 						</googleJavaFormat>
 
 						<!-- make sure every file has the following copyright header.
diff --git a/src/main/java/org/toop/ConsoleGui.java b/src/main/java/org/toop/ConsoleGui.java
index 8c362e7..9be17fc 100644
--- a/src/main/java/org/toop/ConsoleGui.java
+++ b/src/main/java/org/toop/ConsoleGui.java
@@ -1,198 +1,215 @@
 package org.toop;
 
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutionException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.toop.eventbus.*;
 import org.toop.eventbus.Events;
 import org.toop.eventbus.GlobalEventBus;
 import org.toop.game.*;
 import org.toop.game.tictactoe.*;
 
-import com.google.errorprone.annotations.Keep;
-
-import org.toop.eventbus.*;
-
-import java.util.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-
 public class ConsoleGui {
 
-	private static final Logger logger = LogManager.getLogger(ConsoleGui.class);
+    private static final Logger logger = LogManager.getLogger(ConsoleGui.class);
 
-	private Scanner scanner;
+    private Scanner scanner;
 
-	private TicTacToe game;
-	private MinMaxTicTacToe ai;
+    private TicTacToe game;
+    private MinMaxTicTacToe ai;
 
-	private String ai1 = null;
-	private String ai2 = null;
+    private String ai1 = null;
+    private String ai2 = null;
 
-	private String serverId = null;
-	private String connectionId = null;
-	private String ticTacToeGameId = null;
+    private String serverId = null;
+    private String connectionId = null;
+    private String ticTacToeGameId = null;
 
-	public ConsoleGui() throws ExecutionException, InterruptedException {
-		scanner = new Scanner(System.in);
-		Random random = new Random(3453498);
+    public ConsoleGui() throws ExecutionException, InterruptedException {
+        scanner = new Scanner(System.in);
+        Random random = new Random(3453498);
 
-		int mode = -1;
+        int mode = -1;
 
-		System.out.print(
+        System.out.print(
                 """
-                        1. player vs player
-                        2. player vs ai
-                        3. ai vs player
-                        4. ai v ai
-                        Choose mode (default is 1):\s""");
-		String modeString = scanner.nextLine();
+                1. player vs player
+                2. player vs ai
+                3. ai vs player
+                4. ai v ai
+                Choose mode (default is 1):\s\
+                """);
+        String modeString = scanner.nextLine();
 
-		try {
-			mode = Integer.parseInt(modeString);
-		} catch (Exception e) {
-			logger.error(e.getMessage());
-		}
+        try {
+            mode = Integer.parseInt(modeString);
+        } catch (Exception e) {
+            logger.error(e.getMessage());
+        }
 
-		String player1 = null;
-		String player2 = null;
+        String player1 = null;
+        String player2 = null;
 
-		switch (mode) {
-			// player vs ai
-			case 2: {
-				System.out.print("Please enter your name: ");
-				String name = scanner.nextLine();
+        switch (mode) {
+            // player vs ai
+            case 2:
+                {
+                    System.out.print("Please enter your name: ");
+                    String name = scanner.nextLine();
 
-				player1 = name;
-				ai2 = player2 = "AI#" + random.nextInt();
+                    player1 = name;
+                    ai2 = player2 = "AI#" + random.nextInt();
 
-				break;
-			}
+                    break;
+                }
 
-			// ai vs player
-			case 3: {
-				System.out.print("Enter your name: ");
-				String name = scanner.nextLine();
+            // ai vs player
+            case 3:
+                {
+                    System.out.print("Enter your name: ");
+                    String name = scanner.nextLine();
 
-				ai1 = player1 = "AI#" + random.nextInt();
-				player2 = name;
+                    ai1 = player1 = "AI#" + random.nextInt();
+                    player2 = name;
 
-				break;
-			}
+                    break;
+                }
 
-			// ai vs ai
-			case 4: {
-				ai1 = player1 = "AI#" + random.nextInt();
-				ai2 = player2 = "AI2" + random.nextInt();
+            // ai vs ai
+            case 4:
+                {
+                    ai1 = player1 = "AI#" + random.nextInt();
+                    ai2 = player2 = "AI2" + random.nextInt();
 
-				break;
-			}
+                    break;
+                }
 
-			// player vs player
-			case 1:
-			default: {
-				 System.out.print("Player 1. Please enter your name: ");
-				 String name1 = scanner.nextLine();
+            // player vs player
+            case 1:
+            default:
+                {
+                    System.out.print("Player 1. Please enter your name: ");
+                    String name1 = scanner.nextLine();
 
-				 System.out.print("Player 2. Please enter your name: ");
-				 String name2 = scanner.nextLine();
+                    System.out.print("Player 2. Please enter your name: ");
+                    String name2 = scanner.nextLine();
 
-				 player1 = name1;
-				 player2 = name2;
-			}
-		}
+                    player1 = name1;
+                    player2 = name2;
+                }
+        }
 
-		game = new TicTacToe(player1, player2);
-		ai = new MinMaxTicTacToe();
+        game = new TicTacToe(player1, player2);
+        ai = new MinMaxTicTacToe();
 
-		CompletableFuture<String> serverIdFuture = new CompletableFuture<>();
-        GlobalEventBus.post(new Events.ServerEvents.StartServerRequest("5001", "tictactoe", serverIdFuture));
+        CompletableFuture<String> serverIdFuture = new CompletableFuture<>();
+        GlobalEventBus.post(
+                new Events.ServerEvents.StartServerRequest("5001", "tictactoe", serverIdFuture));
         serverId = serverIdFuture.get();
 
         CompletableFuture<String> connectionIdFuture = new CompletableFuture<>();
-        GlobalEventBus.post(new Events.ServerEvents.StartConnectionRequest("127.0.0.1", "5001", connectionIdFuture));
+        GlobalEventBus.post(
+                new Events.ServerEvents.StartConnectionRequest(
+                        "127.0.0.1", "5001", connectionIdFuture));
         connectionId = connectionIdFuture.get();
 
         CompletableFuture<String> ticTacToeGame = new CompletableFuture<>();
-        GlobalEventBus.post(new Events.ServerEvents.CreateTicTacToeGameRequest(serverId, player1, player2, ticTacToeGame));
+        GlobalEventBus.post(
+                new Events.ServerEvents.CreateTicTacToeGameRequest(
+                        serverId, player1, player2, ticTacToeGame));
         ticTacToeGameId = ticTacToeGame.get();
         GlobalEventBus.post(new Events.ServerEvents.RunTicTacToeGame(serverId, ticTacToeGameId));
-	}
+    }
 
-	public void print() {
-		char[] seperator = new char[game.getSize() * 4 - 1];
-		Arrays.fill(seperator, '-');
+    public void print() {
+        char[] seperator = new char[game.getSize() * 4 - 1];
+        Arrays.fill(seperator, '-');
 
-		for (int i = 0; i < game.getSize(); i++) {
-			String buffer = " ";
+        for (int i = 0; i < game.getSize(); i++) {
+            String buffer = " ";
 
-			for (int j = 0; j < game.getSize() - 1; j++) {
-				buffer += game.getGrid()[i * game.getSize() + j] + " | ";
-			}
+            for (int j = 0; j < game.getSize() - 1; j++) {
+                buffer += game.getGrid()[i * game.getSize() + j] + " | ";
+            }
 
-			buffer += game.getGrid()[i * game.getSize() + game.getSize() - 1];
-			System.out.println(buffer);
+            buffer += game.getGrid()[i * game.getSize() + game.getSize() - 1];
+            System.out.println(buffer);
 
-			if (i < game.getSize() - 1) {
-				System.out.println(seperator);
-			}
-		}
-	}
+            if (i < game.getSize() - 1) {
+                System.out.println(seperator);
+            }
+        }
+    }
 
-	public boolean next() {
-		Player current = game.getCurrentPlayer();
-		int move = -1;
+    public boolean next() {
+        Player current = game.getCurrentPlayer();
+        int move = -1;
 
-		if (ai1 != null && current.name() == ai1 || ai2 != null && current.name() == ai2) {
-			move = ai.findBestMove(game);
-		} else {
-			System.out.printf("%s's (%c) turn. Please choose an empty cell between 0-8: ", current.name(), current.move());
-			String input = scanner.nextLine();
+        if (ai1 != null && current.name() == ai1 || ai2 != null && current.name() == ai2) {
+            move = ai.findBestMove(game);
+        } else {
+            System.out.printf(
+                    "%s's (%c) turn. Please choose an empty cell between 0-8: ",
+                    current.name(), current.move());
+            String input = scanner.nextLine();
 
-			try {
-				move = Integer.parseInt(input);
-			}
-			catch (NumberFormatException e) {
-			}
-		}
+            try {
+                move = Integer.parseInt(input);
+            } catch (NumberFormatException e) {
+            }
+        }
 
-		GameBase.State state = game.play(move);
-		boolean keepRunning = true;
+        GameBase.State state = game.play(move);
+        boolean keepRunning = true;
 
-		switch (state) {
-			case INVALID: {
-				System.out.println("Please select an empty cell. Between 0-8");
-				return true;
-			}
+        switch (state) {
+            case INVALID:
+                {
+                    System.out.println("Please select an empty cell. Between 0-8");
+                    return true;
+                }
 
-			case DRAW: {
-				System.out.println("Game ended in a draw.");
-				keepRunning = false;
-				break;
-			}
+            case DRAW:
+                {
+                    System.out.println("Game ended in a draw.");
+                    keepRunning = false;
+                    break;
+                }
 
-			case WIN: {
-				System.out.printf("%s has won the game.\n", current.name());
-				keepRunning = false;
-				break;
-			}
+            case WIN:
+                {
+                    System.out.printf("%s has won the game.\n", current.name());
+                    keepRunning = false;
+                    break;
+                }
 
-			case NORMAL:
-			default: {
-				keepRunning = true;
-				break;
-			}
-		} 
+            case NORMAL:
+            default:
+                {
+                    keepRunning = true;
+                    break;
+                }
+        }
 
-        GlobalEventBus.post(new Events.ServerEvents.SendCommand(
-                connectionId,
-                "gameid " + ticTacToeGameId, "player " + current.name(), "MOVE", String.valueOf(move)
-        ));
+        GlobalEventBus.post(
+                new Events.ServerEvents.SendCommand(
+                        connectionId,
+                        "gameid " + ticTacToeGameId,
+                        "player " + current.name(),
+                        "MOVE",
+                        String.valueOf(move)));
 
-		if (!keepRunning) {
-			GlobalEventBus.post(new Events.ServerEvents.EndTicTacToeGame(serverId, ticTacToeGameId));
-		}
+        if (!keepRunning) {
+            GlobalEventBus.post(
+                    new Events.ServerEvents.EndTicTacToeGame(serverId, ticTacToeGameId));
+        }
 
-		return keepRunning;
-	}
+        return keepRunning;
+    }
 
-	public GameBase getGame() { return game; }
+    public GameBase getGame() {
+        return game;
+    }
 }
diff --git a/src/main/java/org/toop/Logging.java b/src/main/java/org/toop/Logging.java
index 2b661fd..f60c6d1 100644
--- a/src/main/java/org/toop/Logging.java
+++ b/src/main/java/org/toop/Logging.java
@@ -5,11 +5,8 @@ import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.core.LoggerContext;
 import org.apache.logging.log4j.core.config.Configuration;
 import org.apache.logging.log4j.core.config.LoggerConfig;
-import org.toop.eventbus.EventRegistry;
 
-/**
- * Options for logging.
- */
+/** Options for logging. */
 public final class Logging {
     public static void disableAllLogs() {
         LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
diff --git a/src/main/java/org/toop/Main.java b/src/main/java/org/toop/Main.java
index 473e604..4d5937c 100644
--- a/src/main/java/org/toop/Main.java
+++ b/src/main/java/org/toop/Main.java
@@ -1,69 +1,66 @@
 package org.toop;
 
-import org.toop.frontend.UI.LocalServerSelector;
-import org.toop.eventbus.EventRegistry;
+import java.util.concurrent.ExecutionException;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.backend.ServerManager;
 import org.toop.eventbus.Events;
 import org.toop.eventbus.GlobalEventBus;
-import org.toop.backend.ServerManager;
-
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
 import org.toop.frontend.ConnectionManager;
-import org.toop.frontend.games.LocalTicTacToe;
-
-import java.util.concurrent.ExecutionException;
+import org.toop.frontend.UI.LocalServerSelector;
 
 public class Main {
     private static final Logger logger = LogManager.getLogger(Main.class);
     private static boolean running = false;
 
-	public static void main(String[] args) throws ExecutionException, InterruptedException {
-//        Logging.disableAllLogs();
-//		Logging.enableAllLogsForClass(LocalTicTacToe.class);
-//        Logging.enableLogsForClass(ServerManager.class, Level.ALL);
-//        Logging.enableLogsForClass(TicTacToeServer.class, Level.ALL);
-//        Logging.enableLogsForClass(TcpClient.class, Level.ALL);
-//        Logging.enableLogsForClass(ConnectionManager.class, Level.ALL);
+    public static void main(String[] args) throws ExecutionException, InterruptedException {
+        //        Logging.disableAllLogs();
+        //		Logging.enableAllLogsForClass(LocalTicTacToe.class);
+        //        Logging.enableLogsForClass(ServerManager.class, Level.ALL);
+        //        Logging.enableLogsForClass(TicTacToeServer.class, Level.ALL);
+        //        Logging.enableLogsForClass(TcpClient.class, Level.ALL);
+        //        Logging.enableLogsForClass(ConnectionManager.class, Level.ALL);
         initSystems();
         registerEvents();
 
-//		JFrame frame = new JFrame("Server Settings");
-//		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
-//		frame.setSize(800, 600);
-//		frame.setLocationRelativeTo(null);
-//		frame.setVisible(true);
+        //		JFrame frame = new JFrame("Server Settings");
+        //		frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
+        //		frame.setSize(800, 600);
+        //		frame.setLocationRelativeTo(null);
+        //		frame.setVisible(true);
 
-		javax.swing.SwingUtilities.invokeLater(LocalServerSelector::new);
+        javax.swing.SwingUtilities.invokeLater(LocalServerSelector::new);
 
-//		new Thread(() -> {
-//			LocalServerSelector window = new LocalServerSelector();
-//		}).start();
+        //		new Thread(() -> {
+        //			LocalServerSelector window = new LocalServerSelector();
+        //		}).start();
 
     }
 
-	private static void registerEvents() {
-		GlobalEventBus.subscribeAndRegister(Events.WindowEvents.OnQuitRequested.class, event -> {
-			quit();
-		});
+    private static void registerEvents() {
+        GlobalEventBus.subscribeAndRegister(
+                Events.WindowEvents.OnQuitRequested.class,
+                event -> {
+                    quit();
+                });
 
-		GlobalEventBus.subscribeAndRegister(Events.WindowEvents.OnMouseMove.class, event -> {
-		});
-	}
+        GlobalEventBus.subscribeAndRegister(Events.WindowEvents.OnMouseMove.class, event -> {});
+    }
 
     public static void initSystems() {
         new ServerManager();
         new ConnectionManager();
     }
 
-	private static void quit() {
-		running = false;
-	}
+    private static void quit() {
+        running = false;
+    }
 
-	public static boolean isRunning() {
-		return running;
-	}
+    public static boolean isRunning() {
+        return running;
+    }
 
-	public static void setRunning(boolean running) {
-		Main.running = running;
-	}
+    public static void setRunning(boolean running) {
+        Main.running = running;
+    }
 }
diff --git a/src/main/java/org/toop/backend/ServerManager.java b/src/main/java/org/toop/backend/ServerManager.java
index d05a876..7098812 100644
--- a/src/main/java/org/toop/backend/ServerManager.java
+++ b/src/main/java/org/toop/backend/ServerManager.java
@@ -1,17 +1,15 @@
 package org.toop.backend;
 
-import org.toop.eventbus.Events;
-import org.toop.eventbus.GlobalEventBus;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.toop.backend.tictactoe.TicTacToeServer;
-
 import java.util.ArrayList;
 import java.util.Map;
 import java.util.Objects;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.backend.tictactoe.TicTacToeServer;
+import org.toop.eventbus.Events;
+import org.toop.eventbus.GlobalEventBus;
 
 // TODO more methods.
 
@@ -19,21 +17,24 @@ public class ServerManager {
 
     private static final Logger logger = LogManager.getLogger(ServerManager.class);
 
-    /**
-     * Map of serverId -> Server instances
-     */
+    /** Map of serverId -> Server instances */
     private final Map<String, TcpServer> servers = new ConcurrentHashMap<>();
 
-    /**
-     * Starts a server manager, to manage, servers.
-     */
+    /** Starts a server manager, to manage, servers. */
     public ServerManager() {
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.StartServerRequest.class, this::handleStartServerRequest);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.StartServer.class, this::handleStartServer);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.ForceCloseAllServers.class, _ -> shutdownAll());
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.CreateTicTacToeGameRequest.class, this::handleStartTicTacToeGameOnAServer);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.RunTicTacToeGame.class, this::handleRunTicTacToeGameOnAServer);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.EndTicTacToeGame.class, this::handleEndTicTacToeGameOnAServer);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.StartServerRequest.class, this::handleStartServerRequest);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.StartServer.class, this::handleStartServer);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.ForceCloseAllServers.class, _ -> shutdownAll());
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.CreateTicTacToeGameRequest.class,
+                this::handleStartTicTacToeGameOnAServer);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.RunTicTacToeGame.class, this::handleRunTicTacToeGameOnAServer);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.EndTicTacToeGame.class, this::handleEndTicTacToeGameOnAServer);
     }
 
     private String startServer(String port, String gameType) {
@@ -43,8 +44,7 @@ public class ServerManager {
             TcpServer server = null;
             if (Objects.equals(gameType, "tictactoe")) {
                 server = new TicTacToeServer(Integer.parseInt(port));
-            }
-            else {
+            } else {
                 logger.error("Manager could not create a server for game type: {}", gameType);
                 return null;
             }
@@ -59,28 +59,33 @@ public class ServerManager {
     }
 
     private void handleStartServerRequest(Events.ServerEvents.StartServerRequest request) {
-        request.future().complete(this.startServer(request.port(), request.gameType())); // TODO: Maybe post StartServer event.
+        request.future()
+                .complete(
+                        this.startServer(
+                                request.port(),
+                                request.gameType())); // TODO: Maybe post StartServer event.
     }
 
     private void handleStartServer(Events.ServerEvents.StartServer event) {
-        GlobalEventBus.post(new Events.ServerEvents.ServerStarted(
-                this.startServer(event.port(), event.gameType()),
-                event.port()
-        ));
+        GlobalEventBus.post(
+                new Events.ServerEvents.ServerStarted(
+                        this.startServer(event.port(), event.gameType()), event.port()));
     }
 
-    private void handleStartTicTacToeGameOnAServer(Events.ServerEvents.CreateTicTacToeGameRequest event) {
+    private void handleStartTicTacToeGameOnAServer(
+            Events.ServerEvents.CreateTicTacToeGameRequest event) {
         TicTacToeServer serverThing = (TicTacToeServer) this.servers.get(event.serverUuid());
         String gameId = null;
         if (serverThing != null) {
             try {
                 gameId = serverThing.newGame(event.playerA(), event.playerB());
                 logger.info("Created game on server: {}", event.serverUuid());
-            }
-            catch (Exception e) { // TODO: Error handling
+            } catch (Exception e) { // TODO: Error handling
                 logger.error("Could not create game on server: {}", event.serverUuid());
             }
-        } else { logger.warn("Could not find server: {}", event.serverUuid()); }
+        } else {
+            logger.warn("Could not find server: {}", event.serverUuid());
+        }
         event.future().complete(gameId);
     }
 
diff --git a/src/main/java/org/toop/backend/TcpServer.java b/src/main/java/org/toop/backend/TcpServer.java
index 205e968..8955ff0 100644
--- a/src/main/java/org/toop/backend/TcpServer.java
+++ b/src/main/java/org/toop/backend/TcpServer.java
@@ -1,9 +1,5 @@
 package org.toop.backend;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.toop.backend.tictactoe.ParsedCommand;
-
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
@@ -12,18 +8,18 @@ import java.net.ServerSocket;
 import java.net.Socket;
 import java.util.Map;
 import java.util.concurrent.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.backend.tictactoe.ParsedCommand;
 
 /**
  * Lightweight, thread-pool based TCP server base class.
  *
- * Responsibilities:
- * - accept sockets
- * - hand off socket I/O to connectionExecutor (pooled threads)
- * - provide thread-safe queues (receivedQueue / sendQueue) to subclasses
+ * <p>Responsibilities: - accept sockets - hand off socket I/O to connectionExecutor (pooled
+ * threads) - provide thread-safe queues (receivedQueue / sendQueue) to subclasses
  *
- * Notes:
- * - Subclasses should consume receivedQueue (or call getNewestCommand()) and
- *   use sendQueue to send messages to all clients (or per-client, if implemented).
+ * <p>Notes: - Subclasses should consume receivedQueue (or call getNewestCommand()) and use
+ * sendQueue to send messages to all clients (or per-client, if implemented).
  */
 public abstract class TcpServer implements Runnable {
 
@@ -58,8 +54,8 @@ public abstract class TcpServer implements Runnable {
     }
 
     /**
-     * Default run: accept connections and hand off to connectionExecutor.
-     * Subclasses overriding run() should still call startWorkers(Socket) for each accepted socket.
+     * Default run: accept connections and hand off to connectionExecutor. Subclasses overriding
+     * run() should still call startWorkers(Socket) for each accepted socket.
      */
     @Override
     public void run() {
@@ -81,80 +77,112 @@ public abstract class TcpServer implements Runnable {
     }
 
     /**
-     * Listen/Write workers for an accepted client socket.
-     * This method submits two tasks to the connectionExecutor:
-     *  - inputLoop: reads lines and enqueues them to receivedQueue
-     *  - outputLoop: polls sendQueue and writes messages to the client
+     * Listen/Write workers for an accepted client socket. This method submits two tasks to the
+     * connectionExecutor: - inputLoop: reads lines and enqueues them to receivedQueue - outputLoop:
+     * polls sendQueue and writes messages to the client
      *
-     * Note: This is a simple model where sendQueue is global; if you need per-client
+     * <p>Note: This is a simple model where sendQueue is global; if you need per-client
      * send-queues, adapt this method to use one per socket.
      */
     protected void startWorkers(Socket clientSocket) {
         try {
-            BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+            BufferedReader in =
+                    new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true);
 
             // Input task: read lines and put them on receivedQueue
-            Runnable inputTask = () -> {
-                logger.info("Starting read loop for {}", clientSocket.getRemoteSocketAddress());
-                try {
-                    String line;
-                    while (running && (line = in.readLine()) != null) {
-                        if (line.isEmpty()) continue;
-                        logger.debug("Received from {}: {}", clientSocket.getRemoteSocketAddress(), line);
+            Runnable inputTask =
+                    () -> {
+                        logger.info(
+                                "Starting read loop for {}", clientSocket.getRemoteSocketAddress());
+                        try {
+                            String line;
+                            while (running && (line = in.readLine()) != null) {
+                                if (line.isEmpty()) continue;
+                                logger.debug(
+                                        "Received from {}: {}",
+                                        clientSocket.getRemoteSocketAddress(),
+                                        line);
 
-                        boolean offered = false;
-                        for (int i = 0; i < RETRY_ATTEMPTS && !offered; i++) {
-                            try {
-                                // Use offer to avoid blocking indefinitely; adapt timeout/policy as needed
-                                offered = this.receivedQueue.offer(line, 200, TimeUnit.MILLISECONDS);
-                            } catch (InterruptedException ie) {
-                                Thread.currentThread().interrupt();
-                                break;
+                                boolean offered = false;
+                                for (int i = 0; i < RETRY_ATTEMPTS && !offered; i++) {
+                                    try {
+                                        // Use offer to avoid blocking indefinitely; adapt
+                                        // timeout/policy as needed
+                                        offered =
+                                                this.receivedQueue.offer(
+                                                        line, 200, TimeUnit.MILLISECONDS);
+                                    } catch (InterruptedException ie) {
+                                        Thread.currentThread().interrupt();
+                                        break;
+                                    }
+                                }
+
+                                if (!offered) {
+                                    logger.warn(
+                                            "Backpressure: dropping line from {}: {}",
+                                            clientSocket.getRemoteSocketAddress(),
+                                            line);
+                                    // Policy choice: drop, notify, or close connection. We drop
+                                    // here.
+                                }
                             }
+                        } catch (IOException e) {
+                            logger.info(
+                                    "Connection closed by remote: {}",
+                                    clientSocket.getRemoteSocketAddress());
+                        } finally {
+                            try {
+                                clientSocket.close();
+                            } catch (IOException ignored) {
+                            }
+                            logger.info(
+                                    "Stopped read loop for {}",
+                                    clientSocket.getRemoteSocketAddress());
                         }
-
-                        if (!offered) {
-                            logger.warn("Backpressure: dropping line from {}: {}", clientSocket.getRemoteSocketAddress(), line);
-                            // Policy choice: drop, notify, or close connection. We drop here.
-                        }
-                    }
-                } catch (IOException e) {
-                    logger.info("Connection closed by remote: {}", clientSocket.getRemoteSocketAddress());
-                } finally {
-                    try {
-                        clientSocket.close();
-                    } catch (IOException ignored) {}
-                    logger.info("Stopped read loop for {}", clientSocket.getRemoteSocketAddress());
-                }
-            };
+                    };
 
             // Output task: poll global sendQueue and write to this specific client.
-            // NOTE: With a single global sendQueue, every message is sent to every connected client.
+            // NOTE: With a single global sendQueue, every message is sent to every connected
+            // client.
             // If you want per-client sends, change this to use per-client queue map.
-            Runnable outputTask = () -> {
-                logger.info("Starting write loop for {}", clientSocket.getRemoteSocketAddress());
-                try {
-                    while (running && !clientSocket.isClosed()) {
-                        String msg = sendQueue.poll(WAIT_TIME, TimeUnit.MILLISECONDS);
-                        if (msg != null) {
-                            out.println(msg);
-                            out.flush();
-                            logger.debug("Sent to {}: {}", clientSocket.getRemoteSocketAddress(), msg);
+            Runnable outputTask =
+                    () -> {
+                        logger.info(
+                                "Starting write loop for {}",
+                                clientSocket.getRemoteSocketAddress());
+                        try {
+                            while (running && !clientSocket.isClosed()) {
+                                String msg = sendQueue.poll(WAIT_TIME, TimeUnit.MILLISECONDS);
+                                if (msg != null) {
+                                    out.println(msg);
+                                    out.flush();
+                                    logger.debug(
+                                            "Sent to {}: {}",
+                                            clientSocket.getRemoteSocketAddress(),
+                                            msg);
+                                }
+                            }
+                        } catch (InterruptedException e) {
+                            Thread.currentThread().interrupt();
+                            logger.info(
+                                    "Writer interrupted for {}",
+                                    clientSocket.getRemoteSocketAddress());
+                        } catch (Exception e) {
+                            logger.error(
+                                    "Writer error for {}: {}",
+                                    clientSocket.getRemoteSocketAddress(),
+                                    e.toString());
+                        } finally {
+                            try {
+                                clientSocket.close();
+                            } catch (IOException ignored) {
+                            }
+                            logger.info(
+                                    "Stopped write loop for {}",
+                                    clientSocket.getRemoteSocketAddress());
                         }
-                    }
-                } catch (InterruptedException e) {
-                    Thread.currentThread().interrupt();
-                    logger.info("Writer interrupted for {}", clientSocket.getRemoteSocketAddress());
-                } catch (Exception e) {
-                    logger.error("Writer error for {}: {}", clientSocket.getRemoteSocketAddress(), e.toString());
-                } finally {
-                    try {
-                        clientSocket.close();
-                    } catch (IOException ignored) {}
-                    logger.info("Stopped write loop for {}", clientSocket.getRemoteSocketAddress());
-                }
-            };
+                    };
 
             // Input and Output mappings
             connectionExecutor.submit(inputTask);
@@ -164,13 +192,14 @@ public abstract class TcpServer implements Runnable {
             logger.error("Could not start workers for client: {}", e.toString());
             try {
                 clientSocket.close();
-            } catch (IOException ignored) {}
+            } catch (IOException ignored) {
+            }
         }
     }
 
     /**
-     * Convenience: wrapper to obtain the latest command (non-blocking poll).
-     * Subclasses can use this, but for blocking behavior consider using receivedQueue.take()
+     * Convenience: wrapper to obtain the latest command (non-blocking poll). Subclasses can use
+     * this, but for blocking behavior consider using receivedQueue.take()
      */
     protected ParsedCommand getNewestCommand() {
         try {
@@ -183,19 +212,20 @@ public abstract class TcpServer implements Runnable {
         return null;
     }
 
-    /**
-     * Stop server and cleanup executors/sockets.
-     */
+    /** Stop server and cleanup executors/sockets. */
     public void stop() {
         running = false;
 
         try {
             serverSocket.close();
-        } catch (IOException ignored) {}
+        } catch (IOException ignored) {
+        }
 
         connectionExecutor.shutdownNow();
 
-        logger.info("TcpServer stopped. receivedQueue size={}, sendQueue size={}",
-                receivedQueue.size(), sendQueue.size());
+        logger.info(
+                "TcpServer stopped. receivedQueue size={}, sendQueue size={}",
+                receivedQueue.size(),
+                sendQueue.size());
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/backend/tictactoe/ParsedCommand.java b/src/main/java/org/toop/backend/tictactoe/ParsedCommand.java
index e639323..6ed714d 100644
--- a/src/main/java/org/toop/backend/tictactoe/ParsedCommand.java
+++ b/src/main/java/org/toop/backend/tictactoe/ParsedCommand.java
@@ -1,11 +1,10 @@
 package org.toop.backend.tictactoe;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
 import java.util.ArrayList;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 public class ParsedCommand {
     private static final Logger logger = LogManager.getLogger(ParsedCommand.class);
@@ -37,8 +36,10 @@ public class ParsedCommand {
         }
 
         // Case-insensitive regex to match: game_id {id} player {name}
-        Pattern pattern = Pattern.compile(
-                "(?i)\\bgame[_]?id\\s+(\\S+)\\s+player\\s+(\\S+)", Pattern.CASE_INSENSITIVE);
+        Pattern pattern =
+                Pattern.compile(
+                        "(?i)\\bgame[_]?id\\s+(\\S+)\\s+player\\s+(\\S+)",
+                        Pattern.CASE_INSENSITIVE);
         Matcher matcher = pattern.matcher(receivedCommand);
 
         String tempGameId = null;
@@ -46,8 +47,8 @@ public class ParsedCommand {
         String tempPayload = receivedCommand;
 
         if (matcher.find()) {
-            tempGameId = matcher.group(1);  // first capture group → game_id
-            tempPlayer = matcher.group(2);  // second capture group → player
+            tempGameId = matcher.group(1); // first capture group → game_id
+            tempPlayer = matcher.group(2); // second capture group → player
             // Remove the matched part from the original command
             tempPayload = matcher.replaceFirst("").trim();
         }
@@ -129,8 +130,9 @@ public class ParsedCommand {
                 }
             }
             case CHALLENGE -> {
-                if (!segments[1].isEmpty() && segments[1].equals("accept") &&
-                        !segments[2].isEmpty()) {
+                if (!segments[1].isEmpty()
+                        && segments[1].equals("accept")
+                        && !segments[2].isEmpty()) {
                     this.command = commandEnum;
                     this.arguments = new ArrayList<>(2);
                     this.arguments.add(segments[1]);
@@ -174,9 +176,10 @@ public class ParsedCommand {
                     return;
                 }
             }
-//                case GET -> { // TODO: Get needs to accept different game types later. And get the players
-//
-//                }
+            //                case GET -> { // TODO: Get needs to accept different game types later.
+            // And get the players
+            //
+            //                }
             case BYE, DISCONNECT, LOGOUT, QUIT, EXIT, FORFEIT, SUBSCRIBE -> {
                 this.command = commandEnum;
                 this.arguments = null;
@@ -199,9 +202,9 @@ public class ParsedCommand {
             }
         }
     }
-//
-//    public ParsedCommand parseCommand(String command) {
-//        return null;
-//    }
+    //
+    //    public ParsedCommand parseCommand(String command) {
+    //        return null;
+    //    }
 
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/backend/tictactoe/TicTacToeServer.java b/src/main/java/org/toop/backend/tictactoe/TicTacToeServer.java
index 77b9854..0094567 100644
--- a/src/main/java/org/toop/backend/tictactoe/TicTacToeServer.java
+++ b/src/main/java/org/toop/backend/tictactoe/TicTacToeServer.java
@@ -1,21 +1,21 @@
 package org.toop.backend.tictactoe;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.toop.game.tictactoe.TicTacToe;
-import org.toop.backend.TcpServer;
-
 import java.io.IOException;
 import java.net.Socket;
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.backend.TcpServer;
+import org.toop.game.tictactoe.TicTacToe;
 
 public class TicTacToeServer extends TcpServer {
 
     protected static final Logger logger = LogManager.getLogger(TicTacToeServer.class);
 
-    private final ExecutorService connectionExecutor = Executors.newCachedThreadPool(); // socket I/O
+    private final ExecutorService connectionExecutor =
+            Executors.newCachedThreadPool(); // socket I/O
     private final ExecutorService dispatcherExecutor;
     private final ExecutorService forwarderExecutor = Executors.newSingleThreadExecutor();
 
@@ -26,7 +26,9 @@ public class TicTacToeServer extends TcpServer {
         super(port);
 
         int dispatchers = Math.max(2, Runtime.getRuntime().availableProcessors());
-        this.dispatcherExecutor = Executors.newFixedThreadPool(dispatchers + 1); // TODO: Magic number for forwardMessages
+        this.dispatcherExecutor =
+                Executors.newFixedThreadPool(
+                        dispatchers + 1); // TODO: Magic number for forwardMessages
         this.incomingCommands = new LinkedBlockingQueue<>(5_000);
 
         forwarderExecutor.submit(this::forwardLoop);
@@ -52,9 +54,7 @@ public class TicTacToeServer extends TcpServer {
         }
     }
 
-    /**
-     * Forwards raw messages from TcpServer.receivedQueue into ParsedCommand objects.
-     */
+    /** Forwards raw messages from TcpServer.receivedQueue into ParsedCommand objects. */
     private void forwardLoop() {
         logger.info("Forwarder loop started");
         try {
@@ -74,9 +74,7 @@ public class TicTacToeServer extends TcpServer {
         }
     }
 
-    /**
-     * Dispatches parsed commands into the game logic.
-     */
+    /** Dispatches parsed commands into the game logic. */
     private void dispatchLoop() {
         logger.info("Dispatcher thread started");
         try {
@@ -91,9 +89,13 @@ public class TicTacToeServer extends TcpServer {
                 TicTacToe game = this.games.get(command.gameId);
                 if (game != null) {
                     game.addCommandToQueue(command);
-                    logger.info("Dispatched command {} to game {}", command.toString(), command.gameId);
+                    logger.info(
+                            "Dispatched command {} to game {}", command.toString(), command.gameId);
                 } else {
-                    logger.warn("No active game with ID {} for command {}", command.gameId, command.toString());
+                    logger.warn(
+                            "No active game with ID {} for command {}",
+                            command.gameId,
+                            command.toString());
                     // TODO: reply back
                 }
             }
@@ -109,12 +111,18 @@ public class TicTacToeServer extends TcpServer {
         }
 
         if (command.command == TicTacToeServerCommand.CREATE_GAME) {
-            String gameId = this.newGame((String) command.arguments.getFirst(), (String) command.arguments.get(1));
+            String gameId =
+                    this.newGame(
+                            (String) command.arguments.getFirst(),
+                            (String) command.arguments.get(1));
             this.sendQueue.offer("game created successfully|gameid " + gameId);
         } else if (command.command == TicTacToeServerCommand.START_GAME) {
             boolean success = this.runGame((String) command.arguments.getFirst());
-            if (success) {this.sendQueue.offer("svr game is running successfully");}
-            else {this.sendQueue.offer("svr running game failed");}
+            if (success) {
+                this.sendQueue.offer("svr game is running successfully");
+            } else {
+                this.sendQueue.offer("svr running game failed");
+            }
         } else if (command.command == TicTacToeServerCommand.END_GAME) {
             this.endGame((String) command.arguments.getFirst());
             this.sendQueue.offer("svr game ended successfully");
@@ -128,17 +136,21 @@ public class TicTacToeServer extends TcpServer {
     }
 
     public void forwardGameMessages(TicTacToe game) {
-        dispatcherExecutor.submit(() -> {
-            try {
-                while (isRunning()) {
-                    String msg = game.sendQueue.take(); // blocks until a message is added to the queue
-                    logger.info("Games: {}, Adding: {} to the send queue", game.gameId, msg);
-                    this.sendQueue.put(msg); // push to network layer
-                }
-            } catch (InterruptedException e) {
-                Thread.currentThread().interrupt();
-            }
-        });
+        dispatcherExecutor.submit(
+                () -> {
+                    try {
+                        while (isRunning()) {
+                            String msg =
+                                    game.sendQueue
+                                            .take(); // blocks until a message is added to the queue
+                            logger.info(
+                                    "Games: {}, Adding: {} to the send queue", game.gameId, msg);
+                            this.sendQueue.put(msg); // push to network layer
+                        }
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                    }
+                });
     }
 
     public String newGame(String playerA, String playerB) {
@@ -172,4 +184,4 @@ public class TicTacToeServer extends TcpServer {
             logger.warn("Tried to end unknown game {}", gameId);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/backend/tictactoe/TicTacToeServerCommand.java b/src/main/java/org/toop/backend/tictactoe/TicTacToeServerCommand.java
index c7dfc6b..b8a2be0 100644
--- a/src/main/java/org/toop/backend/tictactoe/TicTacToeServerCommand.java
+++ b/src/main/java/org/toop/backend/tictactoe/TicTacToeServerCommand.java
@@ -6,13 +6,9 @@ public enum TicTacToeServerCommand {
     CREATE_GAME,
     START_GAME,
     END_GAME,
-    /**
-     * Login, "username"
-     */
+    /** Login, "username" */
     LOGIN,
-    /**
-     * Logout, "username"
-     */
+    /** Logout, "username" */
     LOGOUT,
     EXIT,
     QUIT,
@@ -26,13 +22,21 @@ public enum TicTacToeServerCommand {
     MESSAGE,
     HELP;
 
-    private static final EnumSet<TicTacToeServerCommand> VALID_COMMANDS = EnumSet.of(
-        TicTacToeServerCommand.LOGIN,     TicTacToeServerCommand.LOGOUT,     TicTacToeServerCommand.EXIT,
-        TicTacToeServerCommand.QUIT,      TicTacToeServerCommand.DISCONNECT, TicTacToeServerCommand.BYE,
-        TicTacToeServerCommand.GET,       TicTacToeServerCommand.SUBSCRIBE,  TicTacToeServerCommand.MOVE,
-        TicTacToeServerCommand.CHALLENGE, TicTacToeServerCommand.FORFEIT,
-        TicTacToeServerCommand.MESSAGE,   TicTacToeServerCommand.HELP
-    );
+    private static final EnumSet<TicTacToeServerCommand> VALID_COMMANDS =
+            EnumSet.of(
+                    TicTacToeServerCommand.LOGIN,
+                    TicTacToeServerCommand.LOGOUT,
+                    TicTacToeServerCommand.EXIT,
+                    TicTacToeServerCommand.QUIT,
+                    TicTacToeServerCommand.DISCONNECT,
+                    TicTacToeServerCommand.BYE,
+                    TicTacToeServerCommand.GET,
+                    TicTacToeServerCommand.SUBSCRIBE,
+                    TicTacToeServerCommand.MOVE,
+                    TicTacToeServerCommand.CHALLENGE,
+                    TicTacToeServerCommand.FORFEIT,
+                    TicTacToeServerCommand.MESSAGE,
+                    TicTacToeServerCommand.HELP);
 
     public static EnumSet<TicTacToeServerCommand> getValidCommands() {
         return VALID_COMMANDS;
@@ -65,5 +69,4 @@ public enum TicTacToeServerCommand {
         }
         return null;
     }
-
 }
diff --git a/src/main/java/org/toop/backend/tictactoe/TicTacToeServerMessage.java b/src/main/java/org/toop/backend/tictactoe/TicTacToeServerMessage.java
index bb9f2e1..e8ca384 100644
--- a/src/main/java/org/toop/backend/tictactoe/TicTacToeServerMessage.java
+++ b/src/main/java/org/toop/backend/tictactoe/TicTacToeServerMessage.java
@@ -7,9 +7,11 @@ public enum TicTacToeServerMessage {
     ERR,
     SVR;
 
-    private static final EnumSet<TicTacToeServerMessage> VALID_COMMANDS = EnumSet.of(
-        TicTacToeServerMessage.OK,     TicTacToeServerMessage.ERR,     TicTacToeServerMessage.SVR
-    );
+    private static final EnumSet<TicTacToeServerMessage> VALID_COMMANDS =
+            EnumSet.of(
+                    TicTacToeServerMessage.OK,
+                    TicTacToeServerMessage.ERR,
+                    TicTacToeServerMessage.SVR);
 
     public static EnumSet<TicTacToeServerMessage> getValidCommands() {
         return VALID_COMMANDS;
@@ -41,5 +43,4 @@ public enum TicTacToeServerMessage {
         }
         return null;
     }
-
 }
diff --git a/src/main/java/org/toop/core/FileSystem.java b/src/main/java/org/toop/core/FileSystem.java
index d5e7ae4..54b403a 100644
--- a/src/main/java/org/toop/core/FileSystem.java
+++ b/src/main/java/org/toop/core/FileSystem.java
@@ -1,34 +1,34 @@
 package org.toop.core;
 
 import java.io.*;
-
-import org.apache.logging.log4j.Logger;
 import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
 public class FileSystem {
-	public record File(String path, CharSequence buffer) {};
+    public record File(String path, CharSequence buffer) {}
+    ;
 
     private static final Logger logger = LogManager.getLogger(FileSystem.class);
 
-	public static File read(String path) {
-		File file;
+    public static File read(String path) {
+        File file;
 
-		try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
-			StringBuilder buffer = new StringBuilder();
-			String line = reader.readLine();
+        try (BufferedReader reader = new BufferedReader(new FileReader(path))) {
+            StringBuilder buffer = new StringBuilder();
+            String line = reader.readLine();
 
-			while (line != null) {
-				buffer.append(line);
-				buffer.append(System.lineSeparator());
-				line = reader.readLine();
-			}
+            while (line != null) {
+                buffer.append(line);
+                buffer.append(System.lineSeparator());
+                line = reader.readLine();
+            }
 
-			file = new File(path, buffer);
-		} catch (IOException e) {
-			logger.error("{}", e.getMessage());
-			return null;
-		}
+            file = new File(path, buffer);
+        } catch (IOException e) {
+            logger.error("{}", e.getMessage());
+            return null;
+        }
 
-		return file;
-	}
+        return file;
+    }
 }
diff --git a/src/main/java/org/toop/core/ICallable.java b/src/main/java/org/toop/core/ICallable.java
index fa23c8b..4be42c6 100644
--- a/src/main/java/org/toop/core/ICallable.java
+++ b/src/main/java/org/toop/core/ICallable.java
@@ -1,5 +1,5 @@
 package org.toop.core;
 
 public interface ICallable<T> {
-	public T call();
+    public T call();
 }
diff --git a/src/main/java/org/toop/core/Window.java b/src/main/java/org/toop/core/Window.java
index 856e5f9..e9f890b 100644
--- a/src/main/java/org/toop/core/Window.java
+++ b/src/main/java/org/toop/core/Window.java
@@ -1,51 +1,50 @@
 package org.toop.core;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.toop.frontend.platform.core.glfw.GlfwWindow;
 
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
-
 public abstract class Window {
-	public enum API {
-		NONE,
-		GLFW,
-	}
+    public enum API {
+        NONE,
+        GLFW,
+    }
 
-	public record Size(int width, int height) {}
+    public record Size(int width, int height) {}
 
     protected static final Logger logger = LogManager.getLogger(Window.class);
 
-	private static API api = API.NONE;
-	private static Window instance = null;
+    private static API api = API.NONE;
+    private static Window instance = null;
 
-	public static Window setup(API api, String title, Size size) {
-		if (instance != null) {
-			logger.warn("Window is already setup.");
-			return instance;
-		}
+    public static Window setup(API api, String title, Size size) {
+        if (instance != null) {
+            logger.warn("Window is already setup.");
+            return instance;
+        }
 
-		switch (api) {
-			case GLFW:
-				instance = new GlfwWindow(title, size);
-				break;
+        switch (api) {
+            case GLFW:
+                instance = new GlfwWindow(title, size);
+                break;
 
-			default:
-				logger.fatal("No valid window api chosen");
-				return null;
-		}
+            default:
+                logger.fatal("No valid window api chosen");
+                return null;
+        }
 
-		Window.api = api;
-		return instance;
-	}
+        Window.api = api;
+        return instance;
+    }
 
-	public static API getApi() {
-		return api;
-	}
+    public static API getApi() {
+        return api;
+    }
 
-	public void cleanup() {
-		instance = null;
-		logger.info("Window cleanup.");
-	}
+    public void cleanup() {
+        instance = null;
+        logger.info("Window cleanup.");
+    }
 
-	public abstract void update();
+    public abstract void update();
 }
diff --git a/src/main/java/org/toop/eventbus/EventMeta.java b/src/main/java/org/toop/eventbus/EventMeta.java
index 3ecea2d..913345c 100644
--- a/src/main/java/org/toop/eventbus/EventMeta.java
+++ b/src/main/java/org/toop/eventbus/EventMeta.java
@@ -1,8 +1,6 @@
 package org.toop.eventbus;
 
-/**
- * Wraps an event with its type and a ready flag.
- */
+/** Wraps an event with its type and a ready flag. */
 public class EventMeta<T> {
     private final Class<T> type;
     private final Object event;
@@ -32,10 +30,13 @@ public class EventMeta<T> {
 
     @Override
     public String toString() {
-        return "ReadyEvent{" +
-                "type=" + type.getSimpleName() +
-                ", event=" + event +
-                ", ready=" + ready +
-                '}';
+        return "ReadyEvent{"
+                + "type="
+                + type.getSimpleName()
+                + ", event="
+                + event
+                + ", ready="
+                + ready
+                + '}';
     }
 }
diff --git a/src/main/java/org/toop/eventbus/EventRegistry.java b/src/main/java/org/toop/eventbus/EventRegistry.java
index 806898f..0862a5f 100644
--- a/src/main/java/org/toop/eventbus/EventRegistry.java
+++ b/src/main/java/org/toop/eventbus/EventRegistry.java
@@ -1,16 +1,13 @@
 package org.toop.eventbus;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
 import java.util.concurrent.CopyOnWriteArrayList;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 
-/**
- * Thread-safe registry for storing events and tracking readiness of event types.
- */
+/** Thread-safe registry for storing events and tracking readiness of event types. */
 public class EventRegistry {
 
     private static final Logger logger = LogManager.getLogger(EventRegistry.class);
@@ -20,9 +17,7 @@ public class EventRegistry {
 
     private static final Map<Class<?>, Boolean> readyStates = new ConcurrentHashMap<>();
 
-    /**
-     * Stores an event in the registry. Safe for concurrent use.
-     */
+    /** Stores an event in the registry. Safe for concurrent use. */
     public static <T> void storeEvent(EventMeta<T> eventMeta) {
         logger.info("Storing event: {}", eventMeta.toString());
         eventHistory
@@ -30,41 +25,31 @@ public class EventRegistry {
                 .add(new EventEntry<>(eventMeta));
     }
 
-    /**
-     * Marks a specific event type as ready (safe to post).
-     */
+    /** Marks a specific event type as ready (safe to post). */
     public static <T> void markReady(Class<T> type) {
         logger.info("Marking event as ready: {}", type.toString());
         readyStates.put(type, true);
     }
 
-    /**
-     * Marks a specific event type as not ready (posting will fail).
-     */
+    /** Marks a specific event type as not ready (posting will fail). */
     public static <T> void markNotReady(Class<T> type) {
         logger.info("Marking event as not ready: {}", type.toString());
         readyStates.put(type, false);
     }
 
-    /**
-     * Returns true if this event type is marked ready.
-     */
+    /** Returns true if this event type is marked ready. */
     public static <T> boolean isReady(Class<T> type) {
         return readyStates.getOrDefault(type, false);
     }
 
-    /**
-     * Gets all stored events of a given type.
-     */
+    /** Gets all stored events of a given type. */
     @SuppressWarnings("unchecked")
     public static <T> List<EventEntry<T>> getEvents(Class<T> type) {
-        return (List<EventEntry<T>>) (List<?>) eventHistory
-                .getOrDefault(type, new CopyOnWriteArrayList<>());
+        return (List<EventEntry<T>>)
+                (List<?>) eventHistory.getOrDefault(type, new CopyOnWriteArrayList<>());
     }
 
-    /**
-     * Gets the most recent event of a given type, or null if none exist.
-     */
+    /** Gets the most recent event of a given type, or null if none exist. */
     @SuppressWarnings("unchecked")
     public static <T> EventEntry<T> getLastEvent(Class<T> type) {
         List<EventEntry<?>> entries = eventHistory.get(type);
@@ -74,26 +59,20 @@ public class EventRegistry {
         return (EventEntry<T>) entries.getLast();
     }
 
-    /**
-     * Clears the stored events for a given type.
-     */
+    /** Clears the stored events for a given type. */
     public static <T> void clearEvents(Class<T> type) {
         logger.info("Clearing events: {}", type.toString());
         eventHistory.remove(type);
     }
 
-    /**
-     * Clears all events and resets readiness.
-     */
+    /** Clears all events and resets readiness. */
     public static void reset() {
         logger.info("Resetting event registry events");
         eventHistory.clear();
         readyStates.clear();
     }
 
-    /**
-     * Wrapper for stored events, with a ready flag for per-event state.
-     */
+    /** Wrapper for stored events, with a ready flag for per-event state. */
     public static class EventEntry<T> {
         private final T event;
         private volatile boolean ready = false;
@@ -116,10 +95,7 @@ public class EventRegistry {
 
         @Override
         public String toString() {
-            return "EventEntry{" +
-                    "event=" + event +
-                    ", ready=" + ready +
-                    '}';
+            return "EventEntry{" + "event=" + event + ", ready=" + ready + '}';
         }
     }
 }
diff --git a/src/main/java/org/toop/eventbus/Events.java b/src/main/java/org/toop/eventbus/Events.java
index 2ef7d97..908684c 100644
--- a/src/main/java/org/toop/eventbus/Events.java
+++ b/src/main/java/org/toop/eventbus/Events.java
@@ -1,19 +1,15 @@
 package org.toop.eventbus;
 
-import org.toop.core.Window;
-import org.toop.backend.tictactoe.TicTacToeServer;
-
 import java.lang.reflect.Constructor;
 import java.util.Arrays;
 import java.util.concurrent.CompletableFuture;
+import org.toop.backend.tictactoe.TicTacToeServer;
+import org.toop.core.Window;
 
-/**
- * Events that are used in the GlobalEventBus class.
- */
+/** Events that are used in the GlobalEventBus class. */
 public class Events implements IEvents {
 
     /**
-     *
      * WIP, DO NOT USE!
      *
      * @param eventName
@@ -29,7 +25,6 @@ public class Events implements IEvents {
     }
 
     /**
-     *
      * WIP, DO NOT USE!
      *
      * @param eventCategory
@@ -38,15 +33,16 @@ public class Events implements IEvents {
      * @return
      * @throws Exception
      */
-    public static Object get(String eventCategory, String eventName, Object... args) throws Exception {
-        Class<?> clazz = Class.forName("org.toop.eventbus.Events$" + eventCategory + "$" + eventName);
+    public static Object get(String eventCategory, String eventName, Object... args)
+            throws Exception {
+        Class<?> clazz =
+                Class.forName("org.toop.eventbus.Events$" + eventCategory + "$" + eventName);
         Class<?>[] paramTypes = Arrays.stream(args).map(Object::getClass).toArray(Class<?>[]::new);
         Constructor<?> constructor = clazz.getConstructor(paramTypes);
         return constructor.newInstance(args);
     }
 
     /**
-     *
      * WIP, DO NOT USE!
      *
      * @param eventName
@@ -77,29 +73,25 @@ public class Events implements IEvents {
     public static class ServerEvents {
 
         /**
-         * BLOCKING
-         * Requests all active connections. The result is returned via the provided CompletableFuture.
+         * BLOCKING Requests all active connections. The result is returned via the provided
+         * CompletableFuture.
          *
          * @param future List of all connections in string form.
          */
         public record RequestsAllConnections(CompletableFuture<String> future) {}
 
         /**
-         * BLOCKING
-         * Requests all active servers. The result is returned via the provided CompletableFuture.
+         * BLOCKING Requests all active servers. The result is returned via the provided
+         * CompletableFuture.
          *
          * @param future List of all servers in string form.
          */
         public record RequestsAllServers(CompletableFuture<String> future) {}
 
-        /**
-         * Forces closing all active connections immediately.
-         */
+        /** Forces closing all active connections immediately. */
         public record ForceCloseAllConnections() {}
 
-        /**
-         * Forces closing all active servers immediately.
-         */
+        /** Forces closing all active servers immediately. */
         public record ForceCloseAllServers() {}
 
         /**
@@ -111,15 +103,15 @@ public class Events implements IEvents {
         public record StartServer(String port, String gameType) {}
 
         /**
-         * BLOCKING
-         * Requests starting a server with a specific port and game type, and returns a CompletableFuture
-         * that completes when the server has started.
+         * BLOCKING Requests starting a server with a specific port and game type, and returns a
+         * CompletableFuture that completes when the server has started.
          *
          * @param port The port to open the server.
          * @param gameType Either "tictactoe" or ...
          * @param future The uuid of the server.
          */
-        public record StartServerRequest(String port, String gameType, CompletableFuture<String> future) {}
+        public record StartServerRequest(
+                String port, String gameType, CompletableFuture<String> future) {}
 
         /**
          * Represents a server that has successfully started.
@@ -130,15 +122,18 @@ public class Events implements IEvents {
         public record ServerStarted(String uuid, String port) {}
 
         /**
-         * BLOCKING
-         * Requests creation of a TicTacToe game on a specific server.
+         * BLOCKING Requests creation of a TicTacToe game on a specific server.
          *
          * @param serverUuid The unique identifier of the server where the game will be created.
          * @param playerA The name of the first player.
          * @param playerB The name of the second player.
          * @param future The game UUID when the game is created.
          */
-        public record CreateTicTacToeGameRequest(String serverUuid, String playerA, String playerB, CompletableFuture<String> future) {}
+        public record CreateTicTacToeGameRequest(
+                String serverUuid,
+                String playerA,
+                String playerB,
+                CompletableFuture<String> future) {}
 
         /**
          * Requests running a TicTacToe game on a specific server.
@@ -157,7 +152,6 @@ public class Events implements IEvents {
         public record EndTicTacToeGame(String serverUuid, String gameUuid) {}
 
         /**
-         *
          * Triggers starting a server connection.
          *
          * @param ip The IP address of the server to connect to.
@@ -166,20 +160,20 @@ public class Events implements IEvents {
         public record StartConnection(String ip, String port) {}
 
         /**
-         * BLOCKING
-         * Triggers starting a server connection and returns a future.
+         * BLOCKING Triggers starting a server connection and returns a future.
          *
          * @param ip The IP address of the server to connect to.
          * @param port The port of the server to connect to.
          * @param future Returns the UUID of the connection, when connection is established.
          */
-        public record StartConnectionRequest(String ip, String port, CompletableFuture<String> future) {}
+        public record StartConnectionRequest(
+                String ip, String port, CompletableFuture<String> future) {}
 
-//        public record StartGameConnectionRequest(String ip, String port, CompletableFuture<String> future) {}
+        //        public record StartGameConnectionRequest(String ip, String port,
+        // CompletableFuture<String> future) {}
 
         /**
-         * BLOCKING
-         * Triggers starting a server connection and returns a future.
+         * BLOCKING Triggers starting a server connection and returns a future.
          *
          * @param ip The IP address of the server to connect to.
          * @param port The port of the server to connect to.
@@ -192,17 +186,17 @@ public class Events implements IEvents {
          * @param connectionId The UUID of the connection to send the command on.
          * @param args The command arguments.
          */
-        public record SendCommand(String connectionId, String... args) { }
+        public record SendCommand(String connectionId, String... args) {}
 
         /**
-         * WIP
-         * Triggers when a command is sent to a server.
+         * WIP Triggers when a command is sent to a server.
          *
          * @param command The TicTacToeServer instance that executed the command.
          * @param args The command arguments.
          * @param result The result returned from executing the command.
          */
-        public record OnCommand(TicTacToeServer command, String[] args, String result) {} // TODO old
+        public record OnCommand(
+                TicTacToeServer command, String[] args, String result) {} // TODO old
 
         /**
          * Triggers when the server client receives a message.
@@ -249,55 +243,33 @@ public class Events implements IEvents {
          */
         public record CouldNotConnect(Object connectionId) {}
 
-        /**
-         * WIP
-         * Triggers when a connection closes.
-         *
-         */
+        /** WIP Triggers when a connection closes. */
         public record ClosedConnection() {}
 
-        /**
-         * Triggers when a cell is clicked in one of the game boards.
-         */
+        /** Triggers when a cell is clicked in one of the game boards. */
         public record CellClicked(int cell) {}
     }
 
-    public static class EventBusEvents {
-
-    }
+    public static class EventBusEvents {}
 
     public static class WindowEvents {
-		/**
-		* Triggers when the window wants to quit.
-		*/
-		public record OnQuitRequested() {}
+        /** Triggers when the window wants to quit. */
+        public record OnQuitRequested() {}
 
-		/**
-		* Triggers when the window is resized.
-		*/
-		public record OnResize(Window.Size size) {}
+        /** Triggers when the window is resized. */
+        public record OnResize(Window.Size size) {}
 
-		/**
-		* Triggers when the mouse is moved within the window.
-		*/
-		public record OnMouseMove(int x, int y) {}
+        /** Triggers when the mouse is moved within the window. */
+        public record OnMouseMove(int x, int y) {}
 
-		/**
-		* Triggers when the mouse is clicked within the window.
-		*/
-		public record OnMouseClick(int button) {}
+        /** Triggers when the mouse is clicked within the window. */
+        public record OnMouseClick(int button) {}
 
-		/**
-		* Triggers when the mouse is released within the window.
-		*/
-		public record OnMouseRelease(int button) {}
+        /** Triggers when the mouse is released within the window. */
+        public record OnMouseRelease(int button) {}
     }
 
-    public static class TttEvents {
+    public static class TttEvents {}
 
-    }
-
-    public static class AiTttEvents {
-
-    }
+    public static class AiTttEvents {}
 }
diff --git a/src/main/java/org/toop/eventbus/GlobalEventBus.java b/src/main/java/org/toop/eventbus/GlobalEventBus.java
index 3cf4d80..8fba98c 100644
--- a/src/main/java/org/toop/eventbus/GlobalEventBus.java
+++ b/src/main/java/org/toop/eventbus/GlobalEventBus.java
@@ -2,17 +2,12 @@ package org.toop.eventbus;
 
 import com.google.common.eventbus.EventBus;
 import com.google.common.eventbus.Subscribe;
-
 import java.util.function.Consumer;
 
-/**
- * A singleton Event Bus to be used for creating, triggering and activating events.
- */
+/** A singleton Event Bus to be used for creating, triggering and activating events. */
 public class GlobalEventBus {
 
-    /**
-     * Singleton event bus.
-     */
+    /** Singleton event bus. */
     private static EventBus eventBus = new EventBus("global-bus");
 
     private GlobalEventBus() {}
@@ -35,16 +30,13 @@ public class GlobalEventBus {
         eventBus = newBus;
     }
 
-    /**
-     * Reset back to the default global EventBus.
-     */
+    /** Reset back to the default global EventBus. */
     public static void reset() {
         eventBus = new EventBus("global-bus");
     }
 
     /**
-     * Wraps a Consumer into a Guava @Subscribe-compatible listener.
-     * TODO
+     * Wraps a Consumer into a Guava @Subscribe-compatible listener. TODO
      *
      * @param type The event to be used. (e.g. Events.ServerCommand.class)
      * @param action The function, or lambda to run when fired.
@@ -74,7 +66,6 @@ public class GlobalEventBus {
         return listener;
     }
 
-
     /**
      * Wrapper for registering a listener.
      *
@@ -101,9 +92,10 @@ public class GlobalEventBus {
     public static <T> void post(T event) {
         Class<T> type = (Class<T>) event.getClass();
 
-//        if (!EventRegistry.isReady(type)) {
-//            throw new IllegalStateException("Event type not ready: " + type.getSimpleName());
-//        } TODO: Handling non ready events.
+        //        if (!EventRegistry.isReady(type)) {
+        //            throw new IllegalStateException("Event type not ready: " +
+        // type.getSimpleName());
+        //        } TODO: Handling non ready events.
 
         // store in registry
         EventMeta<T> eventMeta = new EventMeta<>(type, event);
@@ -112,5 +104,4 @@ public class GlobalEventBus {
         // post to Guava EventBus
         GlobalEventBus.get().post(event);
     }
-
 }
diff --git a/src/main/java/org/toop/frontend/ConnectionManager.java b/src/main/java/org/toop/frontend/ConnectionManager.java
index 8a6e242..7602091 100644
--- a/src/main/java/org/toop/frontend/ConnectionManager.java
+++ b/src/main/java/org/toop/frontend/ConnectionManager.java
@@ -1,38 +1,40 @@
 package org.toop.frontend;
 
-import org.toop.eventbus.Events;
-import org.toop.eventbus.GlobalEventBus;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.ConcurrentHashMap;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.eventbus.Events;
+import org.toop.eventbus.GlobalEventBus;
 
 public class ConnectionManager {
 
     private static final Logger logger = LogManager.getLogger(ConnectionManager.class);
 
-    /**
-     * Map of serverId -> Server instances
-     */
+    /** Map of serverId -> Server instances */
     private final Map<String, ServerConnection> serverConnections = new ConcurrentHashMap<>();
 
-    /**
-     * Starts a connection manager, to manage, connections.
-     */
+    /** Starts a connection manager, to manage, connections. */
     public ConnectionManager() {
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.StartConnectionRequest.class, this::handleStartConnectionRequest);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.StartConnection.class, this::handleStartConnection);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.SendCommand.class, this::handleCommand);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.Reconnect.class, this::handleReconnect);
-//        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.ChangeConnection.class, this::handleChangeConnection);
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.ForceCloseAllConnections.class, _ -> shutdownAll());
-        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.RequestsAllConnections.class, this::getAllConnections);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.StartConnectionRequest.class,
+                this::handleStartConnectionRequest);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.StartConnection.class, this::handleStartConnection);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.SendCommand.class, this::handleCommand);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.Reconnect.class, this::handleReconnect);
+        //        GlobalEventBus.subscribeAndRegister(Events.ServerEvents.ChangeConnection.class,
+        // this::handleChangeConnection);
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.ForceCloseAllConnections.class, _ -> shutdownAll());
+        GlobalEventBus.subscribeAndRegister(
+                Events.ServerEvents.RequestsAllConnections.class, this::getAllConnections);
     }
 
     private String startConnectionRequest(String ip, String port) {
@@ -49,18 +51,24 @@ public class ConnectionManager {
     }
 
     private void handleStartConnectionRequest(Events.ServerEvents.StartConnectionRequest request) {
-        request.future().complete(this.startConnectionRequest(request.ip(), request.port())); // TODO: Maybe post ConnectionEstablished event.
+        request.future()
+                .complete(
+                        this.startConnectionRequest(
+                                request.ip(),
+                                request.port())); // TODO: Maybe post ConnectionEstablished event.
     }
 
     private void handleStartConnection(Events.ServerEvents.StartConnection event) {
-        GlobalEventBus.post(new Events.ServerEvents.ConnectionEstablished(
-                this.startConnectionRequest(event.ip(), event.port()),
-                event.ip(),
-                event.port()
-        ));
+        GlobalEventBus.post(
+                new Events.ServerEvents.ConnectionEstablished(
+                        this.startConnectionRequest(event.ip(), event.port()),
+                        event.ip(),
+                        event.port()));
     }
 
-    private void handleCommand(Events.ServerEvents.SendCommand event) { // TODO: Move this to ServerConnection class, keep it internal.
+    private void handleCommand(
+            Events.ServerEvents.SendCommand
+                    event) { // TODO: Move this to ServerConnection class, keep it internal.
         ServerConnection serverConnection = this.serverConnections.get(event.connectionId());
         if (serverConnection != null) {
             serverConnection.sendCommandByString(event.args());
@@ -82,18 +90,21 @@ public class ConnectionManager {
         }
     }
 
-//    private void handleChangeConnection(Events.ServerEvents.ChangeConnection event) {
-//        ServerConnection serverConnection = this.serverConnections.get(event.connectionId());
-//        if (serverConnection != null) {
-//            try {
-//                serverConnection.connect(event.ip(), event.port());
-//                logger.info("Server {} changed connection to {}:{}", event.connectionId(), event.ip(), event.port());
-//            } catch (Exception e) {
-//                logger.error("Server {} failed to change connection", event.connectionId(), e);
-//                GlobalEventBus.post(new Events.ServerEvents.CouldNotConnect(event.connectionId()));
-//            }
-//        }
-//    } TODO
+    //    private void handleChangeConnection(Events.ServerEvents.ChangeConnection event) {
+    //        ServerConnection serverConnection = this.serverConnections.get(event.connectionId());
+    //        if (serverConnection != null) {
+    //            try {
+    //                serverConnection.connect(event.ip(), event.port());
+    //                logger.info("Server {} changed connection to {}:{}", event.connectionId(),
+    // event.ip(), event.port());
+    //            } catch (Exception e) {
+    //                logger.error("Server {} failed to change connection", event.connectionId(),
+    // e);
+    //                GlobalEventBus.post(new
+    // Events.ServerEvents.CouldNotConnect(event.connectionId()));
+    //            }
+    //        }
+    //    } TODO
 
     private void getAllConnections(Events.ServerEvents.RequestsAllConnections request) {
         List<ServerConnection> a = new ArrayList<>(this.serverConnections.values());
@@ -105,4 +116,4 @@ public class ConnectionManager {
         this.serverConnections.clear();
         logger.info("All servers shut down");
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/frontend/ServerConnection.java b/src/main/java/org/toop/frontend/ServerConnection.java
index be8205f..e21eb05 100644
--- a/src/main/java/org/toop/frontend/ServerConnection.java
+++ b/src/main/java/org/toop/frontend/ServerConnection.java
@@ -1,13 +1,12 @@
 package org.toop.frontend;
 
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.toop.eventbus.Events;
-import org.toop.eventbus.GlobalEventBus;
-
 import java.io.IOException;
 import java.net.InetAddress;
 import java.util.concurrent.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.eventbus.Events;
+import org.toop.eventbus.GlobalEventBus;
 
 public final class ServerConnection extends TcpClient implements Runnable {
 
@@ -28,21 +27,20 @@ public final class ServerConnection extends TcpClient implements Runnable {
     }
 
     /**
-     *
      * Sends a command to the server.
      *
      * @param args The arguments for the command.
      */
     public void sendCommandByString(String... args) {
-//        if (!TicTacToeServerCommand.isValid(command)) {
-//            logger.error("Invalid command: {}", command);
-//            return;
-//        } // TODO: DO I CARE?
+        //        if (!TicTacToeServerCommand.isValid(command)) {
+        //            logger.error("Invalid command: {}", command);
+        //            return;
+        //        } // TODO: DO I CARE?
 
-//        if (!this.running) {
-//            logger.warn("Server has been stopped");
-//            return;
-//        } // TODO: Server not running
+        //        if (!this.running) {
+        //            logger.warn("Server has been stopped");
+        //            return;
+        //        } // TODO: Server not running
 
         String command = String.join(" ", args);
 
@@ -69,11 +67,11 @@ public final class ServerConnection extends TcpClient implements Runnable {
     private void stopWorkers() {
         this.running = false;
         this.sendQueue.clear();
-            try {
-                this.closeSocket();
-            } catch (IOException e) {
-                logger.warn("Error closing client socket", e); // TODO: Better log
-            }
+        try {
+            this.closeSocket();
+        } catch (IOException e) {
+            logger.warn("Error closing client socket", e); // TODO: Better log
+        }
 
         this.executor.shutdownNow();
     }
@@ -86,7 +84,9 @@ public final class ServerConnection extends TcpClient implements Runnable {
                 if (received != null) {
                     logger.info("Connection: {} received: '{}'", this.uuid, received);
                     // this.addReceivedMessageToQueue(received); // TODO: Will never go empty
-                    GlobalEventBus.post(new Events.ServerEvents.ReceivedMessage(this.uuid, received)); // TODO: mb change
+                    GlobalEventBus.post(
+                            new Events.ServerEvents.ReceivedMessage(
+                                    this.uuid, received)); // TODO: mb change
                 } else {
                     break;
                 }
@@ -114,7 +114,6 @@ public final class ServerConnection extends TcpClient implements Runnable {
     }
 
     /**
-     *
      * Connect to a new server.
      *
      * @param ip The ip to connect to.
@@ -132,7 +131,6 @@ public final class ServerConnection extends TcpClient implements Runnable {
     }
 
     /**
-     *
      * Reconnects to previous address.
      *
      * @throws IOException wip
@@ -141,14 +139,14 @@ public final class ServerConnection extends TcpClient implements Runnable {
         this.connect(this.serverAddress, this.serverPort);
     }
 
-    /**
-     *
-     * Close connection to server.
-     *
-     */
+    /** Close connection to server. */
     public void closeConnection() {
         this.stopWorkers();
-        logger.info("Closed connection: {}, to server {}:{}", this.uuid, this.serverAddress, this.serverPort);
+        logger.info(
+                "Closed connection: {}, to server {}:{}",
+                this.uuid,
+                this.serverAddress,
+                this.serverPort);
     }
 
     @Override
@@ -164,9 +162,6 @@ public final class ServerConnection extends TcpClient implements Runnable {
     public String toString() {
         return String.format(
                 "Server {ip: \"%s\", port: \"%s\", running: %s}",
-                this.serverAddress, this.serverPort, this.running
-        );
+                this.serverAddress, this.serverPort, this.running);
     }
-
 }
-
diff --git a/src/main/java/org/toop/frontend/TcpClient.java b/src/main/java/org/toop/frontend/TcpClient.java
index 3e2458c..2a3f9d9 100644
--- a/src/main/java/org/toop/frontend/TcpClient.java
+++ b/src/main/java/org/toop/frontend/TcpClient.java
@@ -7,9 +7,7 @@ import java.io.PrintWriter;
 import java.net.InetAddress;
 import java.net.Socket;
 
-/**
- * A simple wrapper for creating TCP clients.
- */
+/** A simple wrapper for creating TCP clients. */
 public abstract class TcpClient {
 
     InetAddress serverAddress;
@@ -61,5 +59,4 @@ public abstract class TcpClient {
     public void close() throws IOException {
         this.socket.close();
     }
-
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/frontend/UI/BackgroundPanel.java b/src/main/java/org/toop/frontend/UI/BackgroundPanel.java
index 8b27b71..23cb0ce 100644
--- a/src/main/java/org/toop/frontend/UI/BackgroundPanel.java
+++ b/src/main/java/org/toop/frontend/UI/BackgroundPanel.java
@@ -1,7 +1,7 @@
 package org.toop.frontend.UI;
 
-import javax.swing.*;
 import java.awt.*;
+import javax.swing.*;
 
 public class BackgroundPanel extends JPanel {
     private Image backgroundImage;
@@ -18,4 +18,4 @@ public class BackgroundPanel extends JPanel {
             g.drawImage(backgroundImage, 0, 0, getWidth(), getHeight(), this);
         }
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/frontend/UI/LocalGameSelector.java b/src/main/java/org/toop/frontend/UI/LocalGameSelector.java
index 524e4c5..e02ffa7 100644
--- a/src/main/java/org/toop/frontend/UI/LocalGameSelector.java
+++ b/src/main/java/org/toop/frontend/UI/LocalGameSelector.java
@@ -1,17 +1,11 @@
 package org.toop.frontend.UI;
 
+import java.awt.*;
+import javax.swing.*;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import org.toop.eventbus.Events;
-import org.toop.eventbus.GlobalEventBus;
 import org.toop.frontend.games.LocalTicTacToe;
 
-import javax.swing.*;
-import java.awt.*;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.ExecutionException;
-
 public class LocalGameSelector extends JFrame {
     private static final Logger logger = LogManager.getLogger(LocalGameSelector.class);
 
@@ -20,7 +14,7 @@ public class LocalGameSelector extends JFrame {
     private JButton startGame;
     private JComboBox playerTypeSelectionBox;
 
-    private JPanel cards;        // CardLayout panel
+    private JPanel cards; // CardLayout panel
     private CardLayout cardLayout;
 
     private UIGameBoard tttBoard;
@@ -70,14 +64,14 @@ public class LocalGameSelector extends JFrame {
 
         if (playerTypes.equals("Player vs Player")) {
             logger.info("Player vs Player");
-            lttt = LocalTicTacToe.createLocal(new boolean[] { false, false });
+            lttt = LocalTicTacToe.createLocal(new boolean[] {false, false});
         } else {
             if (playerTypes.equals("Player vs AI")) {
                 logger.info("Player vs AI");
-                lttt = LocalTicTacToe.createLocal(new boolean[] { false, true });
+                lttt = LocalTicTacToe.createLocal(new boolean[] {false, true});
             } else {
                 logger.info("AI vs Player");
-                lttt = LocalTicTacToe.createLocal(new boolean[] { true, false });
+                lttt = LocalTicTacToe.createLocal(new boolean[] {true, false});
             }
         }
 
diff --git a/src/main/java/org/toop/frontend/UI/LocalServerSelector.java b/src/main/java/org/toop/frontend/UI/LocalServerSelector.java
index 14b0d10..b09f461 100644
--- a/src/main/java/org/toop/frontend/UI/LocalServerSelector.java
+++ b/src/main/java/org/toop/frontend/UI/LocalServerSelector.java
@@ -18,7 +18,6 @@ public class LocalServerSelector {
 
         serverButton.addActionListener(e -> onServerClicked());
         localButton.addActionListener(e -> onLocalClicked());
-        
     }
 
     private void onServerClicked() {
@@ -30,5 +29,4 @@ public class LocalServerSelector {
         frame.dispose();
         new LocalGameSelector();
     }
-
 }
diff --git a/src/main/java/org/toop/frontend/UI/RemoteGameSelector.java b/src/main/java/org/toop/frontend/UI/RemoteGameSelector.java
index 9ce9d4a..c4d8a47 100644
--- a/src/main/java/org/toop/frontend/UI/RemoteGameSelector.java
+++ b/src/main/java/org/toop/frontend/UI/RemoteGameSelector.java
@@ -1,15 +1,14 @@
 package org.toop.frontend.UI;
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-import org.toop.eventbus.Events;
-import org.toop.eventbus.GlobalEventBus;
 
-import javax.swing.*;
 import java.awt.event.ActionEvent;
 import java.util.Objects;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ExecutionException;
-
+import javax.swing.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.toop.eventbus.Events;
+import org.toop.eventbus.GlobalEventBus;
 
 public class RemoteGameSelector {
     private static final Logger logger = LogManager.getLogger(RemoteGameSelector.class);
@@ -29,7 +28,7 @@ public class RemoteGameSelector {
     public RemoteGameSelector() {
         gameSelectorBox.addItem("Tic Tac Toe");
         gameSelectorBox.addItem("Reversi");
-        //todo get supported games from server and add to gameSelectorBox
+        // todo get supported games from server and add to gameSelectorBox
         frame = new JFrame("Game Selector");
         frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
         frame.setSize(1920, 1080);
@@ -38,83 +37,102 @@ public class RemoteGameSelector {
         init();
         frame.add(mainMenu);
         frame.setVisible(true);
-        //GlobalEventBus.subscribeAndRegister() Todo add game panel to frame when connection succeeds
+        // GlobalEventBus.subscribeAndRegister() Todo add game panel to frame when connection
+        // succeeds
 
     }
+
     private void init() {
-        connectButton.addActionListener((ActionEvent e) -> {
-            if(     !nameTextField.getText().isEmpty() &&
-                    !name2TextField.getText().isEmpty()   &&
-                    !ipTextField.getText().isEmpty() &&
-                    !portTextField.getText().isEmpty()) {
+        connectButton.addActionListener(
+                (ActionEvent e) -> {
+                    if (!nameTextField.getText().isEmpty()
+                            && !name2TextField.getText().isEmpty()
+                            && !ipTextField.getText().isEmpty()
+                            && !portTextField.getText().isEmpty()) {
 
-                CompletableFuture<String> serverIdFuture = new CompletableFuture<>();
-                GlobalEventBus.post(new Events.ServerEvents.StartServerRequest(
-                        portTextField.getText(),
-                        Objects.requireNonNull(gameSelectorBox.getSelectedItem()).toString().toLowerCase().replace(" ", ""),
-                        serverIdFuture
-                ));
-                String serverId;
-                try {
-                    serverId = serverIdFuture.get();
-                } catch (InterruptedException | ExecutionException ex) {
-                    throw new RuntimeException(ex);
-                } // TODO: Better error handling to not crash the system.
+                        CompletableFuture<String> serverIdFuture = new CompletableFuture<>();
+                        GlobalEventBus.post(
+                                new Events.ServerEvents.StartServerRequest(
+                                        portTextField.getText(),
+                                        Objects.requireNonNull(gameSelectorBox.getSelectedItem())
+                                                .toString()
+                                                .toLowerCase()
+                                                .replace(" ", ""),
+                                        serverIdFuture));
+                        String serverId;
+                        try {
+                            serverId = serverIdFuture.get();
+                        } catch (InterruptedException | ExecutionException ex) {
+                            throw new RuntimeException(ex);
+                        } // TODO: Better error handling to not crash the system.
 
-                CompletableFuture<String> connectionIdFuture = new CompletableFuture<>();
-                GlobalEventBus.post(new Events.ServerEvents.StartConnectionRequest(
-                        ipTextField.getText(),
-                        portTextField.getText(),
-                        connectionIdFuture
-                ));
-                String connectionId;
-                try {
-                    connectionId = connectionIdFuture.get();
-                } catch (InterruptedException | ExecutionException ex) {
-                    throw new RuntimeException(ex);
-                } // TODO: Better error handling to not crash the system.
+                        CompletableFuture<String> connectionIdFuture = new CompletableFuture<>();
+                        GlobalEventBus.post(
+                                new Events.ServerEvents.StartConnectionRequest(
+                                        ipTextField.getText(),
+                                        portTextField.getText(),
+                                        connectionIdFuture));
+                        String connectionId;
+                        try {
+                            connectionId = connectionIdFuture.get();
+                        } catch (InterruptedException | ExecutionException ex) {
+                            throw new RuntimeException(ex);
+                        } // TODO: Better error handling to not crash the system.
 
-                GlobalEventBus.subscribeAndRegister(Events.ServerEvents.ReceivedMessage.class,
-                    event -> {
-                        if (event.message().equalsIgnoreCase("ok")) {
-                            logger.info("received ok from server.");
-                        } else if (event.message().toLowerCase().startsWith("gameid")) {
-                            String gameId = event.message().toLowerCase().replace("gameid ", "");
-                            GlobalEventBus.post(new Events.ServerEvents.SendCommand("start_game " + gameId));
-                        }
-                        else {
-                            logger.info("{}", event.message());
-                        }
+                        GlobalEventBus.subscribeAndRegister(
+                                Events.ServerEvents.ReceivedMessage.class,
+                                event -> {
+                                    if (event.message().equalsIgnoreCase("ok")) {
+                                        logger.info("received ok from server.");
+                                    } else if (event.message().toLowerCase().startsWith("gameid")) {
+                                        String gameId =
+                                                event.message()
+                                                        .toLowerCase()
+                                                        .replace("gameid ", "");
+                                        GlobalEventBus.post(
+                                                new Events.ServerEvents.SendCommand(
+                                                        "start_game " + gameId));
+                                    } else {
+                                        logger.info("{}", event.message());
+                                    }
+                                });
+
+                        GlobalEventBus.post(
+                                new Events.ServerEvents.SendCommand(
+                                        connectionId,
+                                        "create_game",
+                                        nameTextField.getText(),
+                                        name2TextField.getText()));
+
+                        //                CompletableFuture<String> ticTacToeGame = new
+                        // CompletableFuture<>();
+                        //                GlobalEventBus.post(new
+                        // Events.ServerEvents.CreateTicTacToeGameRequest( // TODO: Make this happen
+                        // through commands send through the connection, instead of an event.
+                        //                        serverId,
+                        //                        nameTextField.getText(),
+                        //                        name2TextField.getText(),
+                        //                        ticTacToeGame
+                        //                ));
+                        //                String ticTacToeGameId;
+                        //                try {
+                        //                    ticTacToeGameId = ticTacToeGame.get();
+                        //                } catch (InterruptedException | ExecutionException ex) {
+                        //                    throw new RuntimeException(ex);
+                        //                } // TODO: Better error handling to not crash the system.
+
+                        frame.remove(mainMenu);
+                        //                UIGameBoard ttt = new UIGameBoard("tic tac toe", "test",
+                        // "test",this); // TODO: Fix later
+                        //                frame.add(ttt.getTTTPanel()); // TODO: Fix later
+                        frame.revalidate();
+                        frame.repaint();
+                    } else {
+                        fillAllFields.setVisible(true);
                     }
-                );
-
-                GlobalEventBus.post(new Events.ServerEvents.SendCommand(connectionId, "create_game", nameTextField.getText(), name2TextField.getText()));
-
-//                CompletableFuture<String> ticTacToeGame = new CompletableFuture<>();
-//                GlobalEventBus.post(new Events.ServerEvents.CreateTicTacToeGameRequest( // TODO: Make this happen through commands send through the connection, instead of an event.
-//                        serverId,
-//                        nameTextField.getText(),
-//                        name2TextField.getText(),
-//                        ticTacToeGame
-//                ));
-//                String ticTacToeGameId;
-//                try {
-//                    ticTacToeGameId = ticTacToeGame.get();
-//                } catch (InterruptedException | ExecutionException ex) {
-//                    throw new RuntimeException(ex);
-//                } // TODO: Better error handling to not crash the system.
-
-
-                frame.remove(mainMenu);
-//                UIGameBoard ttt = new UIGameBoard("tic tac toe", "test", "test",this); // TODO: Fix later
-//                frame.add(ttt.getTTTPanel()); // TODO: Fix later
-                frame.revalidate();
-                frame.repaint();
-            } else {
-                fillAllFields.setVisible(true);
-            }
-        });
+                });
     }
+
     public void returnToMainMenu() {
         frame.removeAll();
         frame.add(mainMenu);
diff --git a/src/main/java/org/toop/frontend/UI/Services.java b/src/main/java/org/toop/frontend/UI/Services.java
index 29d3e0d..988ba0e 100644
--- a/src/main/java/org/toop/frontend/UI/Services.java
+++ b/src/main/java/org/toop/frontend/UI/Services.java
@@ -2,5 +2,4 @@ package org.toop.frontend.UI;
 
 import javax.swing.*;
 
-public class Services {
-}
+public class Services {}
diff --git a/src/main/java/org/toop/frontend/UI/UIGameBoard.java b/src/main/java/org/toop/frontend/UI/UIGameBoard.java
index c861563..a3212a2 100644
--- a/src/main/java/org/toop/frontend/UI/UIGameBoard.java
+++ b/src/main/java/org/toop/frontend/UI/UIGameBoard.java
@@ -1,18 +1,14 @@
 package org.toop.frontend.UI;
 
-import org.toop.eventbus.Events;
-import org.toop.eventbus.GlobalEventBus;
-import org.toop.frontend.games.LocalTicTacToe;
-
-import javax.swing.*;
 import java.awt.*;
 import java.awt.event.ActionEvent;
-import java.util.Objects;
+import javax.swing.*;
+import org.toop.frontend.games.LocalTicTacToe;
 
 public class UIGameBoard {
     private static final int TICTACTOE_SIZE = 3;
 
-    private JPanel tttPanel;                  // Root panel for this game
+    private JPanel tttPanel; // Root panel for this game
     private JButton backToMainMenuButton;
     private JButton[] cells;
     private String currentPlayer = "X";
@@ -32,20 +28,20 @@ public class UIGameBoard {
         // Back button
         backToMainMenuButton = new JButton("Back to Main Menu");
         tttPanel.add(backToMainMenuButton, BorderLayout.SOUTH);
-        backToMainMenuButton.addActionListener(e ->
-                // TODO reset game and connections
-                parent.showMainMenu()
-        );
+        backToMainMenuButton.addActionListener(
+                _ ->
+                        // TODO reset game and connections
+                        parent.showMainMenu());
 
         // Game grid
         JPanel gameGrid = createGridPanel(TICTACTOE_SIZE, TICTACTOE_SIZE);
         tttPanel.add(gameGrid, BorderLayout.CENTER);
 
-//        localTicTacToe.setMoveListener((playerIndex, moveIndex, symbol) -> {
-//            SwingUtilities.invokeLater(() -> {
-//                cells[moveIndex].setText(String.valueOf(symbol));
-//            });
-//        });
+        //        localTicTacToe.setMoveListener((playerIndex, moveIndex, symbol) -> {
+        //            SwingUtilities.invokeLater(() -> {
+        //                cells[moveIndex].setText(String.valueOf(symbol));
+        //            });
+        //        });
 
     }
 
@@ -59,18 +55,25 @@ public class UIGameBoard {
             panel.add(cells[i]);
 
             final int index = i;
-            cells[i].addActionListener((ActionEvent e) -> {
-                int cp = this.localTicTacToe.getCurrentPlayersTurn();
-                if      (cp == 0) { this.currentPlayer = "X"; currentPlayerIndex = 0; }
-                else if (cp == 1) { this.currentPlayer = "O"; currentPlayerIndex = 1; }
-                this.localTicTacToe.move(index);
-                cells[index].setText(currentPlayer);
-            });
+            cells[i].addActionListener(
+                    (ActionEvent _) -> {
+                        int cp = this.localTicTacToe.getCurrentPlayersTurn();
+                        if (cp == 0) {
+                            this.currentPlayer = "X";
+                            currentPlayerIndex = 0;
+                        } else if (cp == 1) {
+                            this.currentPlayer = "O";
+                            currentPlayerIndex = 1;
+                        }
+                        this.localTicTacToe.move(index);
+                        cells[index].setText(currentPlayer);
+                    });
         }
 
         return panel;
     }
-    public void setCell(int index, String move){
+
+    public void setCell(int index, String move) {
         System.out.println(cells[index].getText());
         cells[index].setText(move);
     }
@@ -78,4 +81,4 @@ public class UIGameBoard {
     public JPanel getTTTPanel() {
         return tttPanel;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/frontend/games/LocalTicTacToe.java b/src/main/java/org/toop/frontend/games/LocalTicTacToe.java
index cfce938..745ae22 100644
--- a/src/main/java/org/toop/frontend/games/LocalTicTacToe.java
+++ b/src/main/java/org/toop/frontend/games/LocalTicTacToe.java
@@ -1,5 +1,6 @@
 package org.toop.frontend.games;
 
+import java.util.concurrent.*;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.eventbus.Events;
@@ -9,12 +10,9 @@ import org.toop.game.GameBase;
 import org.toop.game.tictactoe.MinMaxTicTacToe;
 import org.toop.game.tictactoe.TicTacToe;
 
-import java.util.concurrent.*;
-
 /**
- * A representation of a local tic-tac-toe game.
- * Calls are made to a server for information about current game state.
- * MOST OF THIS CODE IS TRASH, THROW IT OUT OF THE WINDOW AFTER DEMO.
+ * A representation of a local tic-tac-toe game. Calls are made to a server for information about
+ * current game state. MOST OF THIS CODE IS TRASH, THROW IT OUT OF THE WINDOW AFTER DEMO.
  */
 public class LocalTicTacToe { // TODO: Implement runnable
     private static final Logger logger = LogManager.getLogger(LocalTicTacToe.class);
@@ -36,38 +34,39 @@ public class LocalTicTacToe { // TODO: Implement runnable
     private TicTacToe ticTacToe;
     private UIGameBoard ui;
 
-
-    /**
-     * Is either 0 or 1.
-     */
+    /** Is either 0 or 1. */
     private int playersTurn = 0;
 
     /**
      * @return The current players turn.
      */
-    public int getCurrentPlayersTurn() { return this.playersTurn; }
+    public int getCurrentPlayersTurn() {
+        return this.playersTurn;
+    }
 
-
-//    LocalTicTacToe(String gameId, String connectionId, String serverId) {
-//        this.gameId = gameId;
-//        this.connectionId = connectionId;
-//        this.serverId = serverId;
-//        this.receivedMessageListener = GlobalEventBus.subscribe(Events.ServerEvents.ReceivedMessage.class, this::receiveMessageAction);
-//        GlobalEventBus.register(this.receivedMessageListener);
-//
-//
-//        this.executor.submit(this::gameThread);
-//    } TODO: If remote server
+    //    LocalTicTacToe(String gameId, String connectionId, String serverId) {
+    //        this.gameId = gameId;
+    //        this.connectionId = connectionId;
+    //        this.serverId = serverId;
+    //        this.receivedMessageListener =
+    // GlobalEventBus.subscribe(Events.ServerEvents.ReceivedMessage.class,
+    // this::receiveMessageAction);
+    //        GlobalEventBus.register(this.receivedMessageListener);
+    //
+    //
+    //        this.executor.submit(this::gameThread);
+    //    } TODO: If remote server
 
     /**
-     *
      * Starts a connection with a remote server.
      *
      * @param ip The IP of the server to connect to.
      * @param port The port of the server to connect to.
      */
     private LocalTicTacToe(String ip, String port) {
-        this.receivedMessageListener = GlobalEventBus.subscribe(Events.ServerEvents.ReceivedMessage.class, this::receiveMessageAction);
+        this.receivedMessageListener =
+                GlobalEventBus.subscribe(
+                        Events.ServerEvents.ReceivedMessage.class, this::receiveMessageAction);
         GlobalEventBus.register(this.receivedMessageListener);
         this.connectionId = this.createConnection(ip, port);
         this.createGame(ip, port);
@@ -100,7 +99,8 @@ public class LocalTicTacToe { // TODO: Implement runnable
 
     private String createServer(String port) {
         CompletableFuture<String> serverIdFuture = new CompletableFuture<>();
-        GlobalEventBus.post(new Events.ServerEvents.StartServerRequest(port, "tictactoe", serverIdFuture));
+        GlobalEventBus.post(
+                new Events.ServerEvents.StartServerRequest(port, "tictactoe", serverIdFuture));
         try {
             return serverIdFuture.get();
         } catch (Exception e) {
@@ -111,7 +111,11 @@ public class LocalTicTacToe { // TODO: Implement runnable
 
     private String createConnection(String ip, String port) {
         CompletableFuture<String> connectionIdFuture = new CompletableFuture<>();
-        GlobalEventBus.post(new Events.ServerEvents.StartConnectionRequest(ip, port, connectionIdFuture)); // TODO: what if server couldn't be started with port.
+        GlobalEventBus.post(
+                new Events.ServerEvents.StartConnectionRequest(
+                        ip,
+                        port,
+                        connectionIdFuture)); // TODO: what if server couldn't be started with port.
         try {
             return connectionIdFuture.get();
         } catch (InterruptedException | ExecutionException e) {
@@ -127,7 +131,9 @@ public class LocalTicTacToe { // TODO: Implement runnable
     }
 
     private void startGame() {
-        if (this.gameId == null) { return; }
+        if (this.gameId == null) {
+            return;
+        }
         this.sendCommand("start_game", this.gameId);
     }
 
@@ -176,9 +182,7 @@ public class LocalTicTacToe { // TODO: Implement runnable
         return ticTacToe.getGrid();
     }
 
-    /**
-     * End the current game.
-     */
+    /** End the current game. */
     public void endGame() {
         sendCommand("gameid", "end_game"); // TODO: Command is a bit wrong.
     }
@@ -187,14 +191,25 @@ public class LocalTicTacToe { // TODO: Implement runnable
      * @param moveIndex The index of the move to make.
      */
     public void move(int moveIndex) {
-        this.executor.submit(() -> {
-            try {
-                if      (this.playersTurn == 0 && !isAiPlayer[0]) { this.moveQueuePlayerA.put(moveIndex); logger.info("Adding player's {}, move: {}", this.playersTurn, moveIndex); }
-                else if (this.playersTurn == 1 && !isAiPlayer[1]) { this.moveQueuePlayerB.put(moveIndex); logger.info("Adding player's {}, move: {}", this.playersTurn, moveIndex); }
-            } catch (InterruptedException e) {
-                logger.error("Could not add player: {}'s, move {}", this.playersTurn, moveIndex); // TODO: Error handling instead of crash.
-            }
-        });
+        this.executor.submit(
+                () -> {
+                    try {
+                        if (this.playersTurn == 0 && !isAiPlayer[0]) {
+                            this.moveQueuePlayerA.put(moveIndex);
+                            logger.info(
+                                    "Adding player's {}, move: {}", this.playersTurn, moveIndex);
+                        } else if (this.playersTurn == 1 && !isAiPlayer[1]) {
+                            this.moveQueuePlayerB.put(moveIndex);
+                            logger.info(
+                                    "Adding player's {}, move: {}", this.playersTurn, moveIndex);
+                        }
+                    } catch (InterruptedException e) {
+                        logger.error(
+                                "Could not add player: {}'s, move {}",
+                                this.playersTurn,
+                                moveIndex); // TODO: Error handling instead of crash.
+                    }
+                });
     }
 
     private void endTheGame() {
@@ -208,7 +223,11 @@ public class LocalTicTacToe { // TODO: Implement runnable
         }
 
         try {
-            logger.info("Received message from " + this.connectionId + ": " + receivedMessage.message());
+            logger.info(
+                    "Received message from "
+                            + this.connectionId
+                            + ": "
+                            + receivedMessage.message());
             this.receivedQueue.put(receivedMessage.message());
         } catch (InterruptedException e) {
             logger.error("Error waiting for received Message", e);
@@ -226,4 +245,4 @@ public class LocalTicTacToe { // TODO: Implement runnable
     public void setUIReference(UIGameBoard uiGameBoard) {
         this.ui = uiGameBoard;
     }
-}
\ No newline at end of file
+}
diff --git a/src/main/java/org/toop/frontend/graphics/Renderer.java b/src/main/java/org/toop/frontend/graphics/Renderer.java
index 66a4bf0..2c4d7b8 100644
--- a/src/main/java/org/toop/frontend/graphics/Renderer.java
+++ b/src/main/java/org/toop/frontend/graphics/Renderer.java
@@ -1,50 +1,50 @@
 package org.toop.frontend.graphics;
 
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.toop.frontend.platform.graphics.opengl.OpenglRenderer;
 
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
-
 public abstract class Renderer {
-	public enum API {
-		NONE,
-		OPENGL,
-	};
+    public enum API {
+        NONE,
+        OPENGL,
+    };
 
     protected static final Logger logger = LogManager.getLogger(Renderer.class);
 
-	private static API api = API.NONE;
-	private static Renderer instance = null;
+    private static API api = API.NONE;
+    private static Renderer instance = null;
 
-	public static Renderer setup(API api) {
-		if (instance != null) {
-			logger.warn("Renderer is already setup.");
-			return instance;
-		}
+    public static Renderer setup(API api) {
+        if (instance != null) {
+            logger.warn("Renderer is already setup.");
+            return instance;
+        }
 
-		switch (api) {
-			case OPENGL:
-				instance = new OpenglRenderer();
-				break;
+        switch (api) {
+            case OPENGL:
+                instance = new OpenglRenderer();
+                break;
 
-			default:
-				logger.fatal("No valid renderer api chosen");
-				return null;
-		}
+            default:
+                logger.fatal("No valid renderer api chosen");
+                return null;
+        }
 
-		Renderer.api = api;
-		return instance;
-	}
+        Renderer.api = api;
+        return instance;
+    }
 
-	public static API getApi() {
-		return api;
-	}
+    public static API getApi() {
+        return api;
+    }
 
-	public void cleanup() {
-		instance = null;
-		logger.info("Renderer cleanup.");
-	}
+    public void cleanup() {
+        instance = null;
+        logger.info("Renderer cleanup.");
+    }
 
-	public abstract void clear();
-	public abstract void render();
+    public abstract void clear();
+
+    public abstract void render();
 }
diff --git a/src/main/java/org/toop/frontend/graphics/Shader.java b/src/main/java/org/toop/frontend/graphics/Shader.java
index fa007a6..cd8516f 100644
--- a/src/main/java/org/toop/frontend/graphics/Shader.java
+++ b/src/main/java/org/toop/frontend/graphics/Shader.java
@@ -3,24 +3,25 @@ package org.toop.frontend.graphics;
 import org.toop.frontend.platform.graphics.opengl.OpenglShader;
 
 public abstract class Shader {
-	public static Shader create(String vertexPath, String fragmentPath) {
-		Shader shader = null;
+    public static Shader create(String vertexPath, String fragmentPath) {
+        Shader shader = null;
 
-		switch (Renderer.getApi()) {
-			case OPENGL:
-				shader = new OpenglShader(vertexPath, fragmentPath);
-				break;
+        switch (Renderer.getApi()) {
+            case OPENGL:
+                shader = new OpenglShader(vertexPath, fragmentPath);
+                break;
 
-			case NONE:
-			default:
-				break;
-		}
+            case NONE:
+            default:
+                break;
+        }
 
-		return shader;
-	}
+        return shader;
+    }
 
-	public abstract void cleanup();
+    public abstract void cleanup();
 
-	public abstract void start();
-	public abstract void stop();
+    public abstract void start();
+
+    public abstract void stop();
 }
diff --git a/src/main/java/org/toop/frontend/graphics/node/Button.java b/src/main/java/org/toop/frontend/graphics/node/Button.java
index 9bc1f3f..429a8d2 100644
--- a/src/main/java/org/toop/frontend/graphics/node/Button.java
+++ b/src/main/java/org/toop/frontend/graphics/node/Button.java
@@ -4,23 +4,30 @@ import org.toop.core.*;
 import org.toop.frontend.math.Color;
 
 public class Button extends Node {
-	ICallable<Boolean> onHover;
-	ICallable<Boolean> onClick;
+    ICallable<Boolean> onHover;
+    ICallable<Boolean> onClick;
 
-	public Button(int x, int y, int width, int height, Color color, ICallable<Boolean> onHover, ICallable<Boolean> onClick) {
-		super(x, y, width, height, color);
+    public Button(
+            int x,
+            int y,
+            int width,
+            int height,
+            Color color,
+            ICallable<Boolean> onHover,
+            ICallable<Boolean> onClick) {
+        super(x, y, width, height, color);
 
-		this.onHover = onHover;
-		this.onClick = onClick;
-	}
+        this.onHover = onHover;
+        this.onClick = onClick;
+    }
 
-	@Override
-	public void hover() {
-		onHover.call();
-	}
+    @Override
+    public void hover() {
+        onHover.call();
+    }
 
-	@Override
-	public void click() {
-		onClick.call();
-	}
+    @Override
+    public void click() {
+        onClick.call();
+    }
 }
diff --git a/src/main/java/org/toop/frontend/graphics/node/Node.java b/src/main/java/org/toop/frontend/graphics/node/Node.java
index 493ccca..781098c 100644
--- a/src/main/java/org/toop/frontend/graphics/node/Node.java
+++ b/src/main/java/org/toop/frontend/graphics/node/Node.java
@@ -4,18 +4,19 @@ import org.toop.frontend.math.Bounds;
 import org.toop.frontend.math.Color;
 
 public abstract class Node {
-	protected Bounds bounds;
-	protected Color color;
+    protected Bounds bounds;
+    protected Color color;
 
-	public Node(int x, int y, int width, int height, Color color) {
-		bounds = new Bounds(x, y, width, height);
-		this.color = color;
-	}
+    public Node(int x, int y, int width, int height, Color color) {
+        bounds = new Bounds(x, y, width, height);
+        this.color = color;
+    }
 
-	public boolean check(int x, int y) {
-		return bounds.check(x, y);
-	}
+    public boolean check(int x, int y) {
+        return bounds.check(x, y);
+    }
 
-	public void hover() {}
-	public void click() {}
+    public void hover() {}
+
+    public void click() {}
 }
diff --git a/src/main/java/org/toop/frontend/graphics/node/NodeManager.java b/src/main/java/org/toop/frontend/graphics/node/NodeManager.java
index f278d0c..00bb2d7 100644
--- a/src/main/java/org/toop/frontend/graphics/node/NodeManager.java
+++ b/src/main/java/org/toop/frontend/graphics/node/NodeManager.java
@@ -1,66 +1,67 @@
 package org.toop.frontend.graphics.node;
 
+import java.util.*;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
 import org.toop.eventbus.*;
 import org.toop.frontend.graphics.Shader;
 
-import java.util.*;
-
-import org.apache.logging.log4j.Logger;
-import org.apache.logging.log4j.LogManager;
-
 public class NodeManager {
     private static final Logger logger = LogManager.getLogger(NodeManager.class);
 
-	private static NodeManager instance = null;
-	
-	public static NodeManager setup() {
-		if (instance != null) {
-			logger.warn("NodeManager is already setup.");
-			return instance;
-		}
+    private static NodeManager instance = null;
 
-		instance = new NodeManager();
-		return instance;
-	}
+    public static NodeManager setup() {
+        if (instance != null) {
+            logger.warn("NodeManager is already setup.");
+            return instance;
+        }
 
-	private Shader shader;
-	private ArrayList<Node> nodes;
-	private Node active;
+        instance = new NodeManager();
+        return instance;
+    }
 
-	private NodeManager() {
-		shader = Shader.create(
-			"src/main/resources/shaders/gui_vertex.glsl",
-			"src/main/resources/shaders/gui_fragment.glsl");
+    private Shader shader;
+    private ArrayList<Node> nodes;
+    private Node active;
 
-		nodes = new ArrayList<Node>();
+    private NodeManager() {
+        shader =
+                Shader.create(
+                        "src/main/resources/shaders/gui_vertex.glsl",
+                        "src/main/resources/shaders/gui_fragment.glsl");
 
-		GlobalEventBus.subscribeAndRegister(Events.WindowEvents.OnMouseMove.class, event -> {
-			for (int i = 0; i < nodes.size(); i++) {
-				Node node = nodes.get(i);
+        nodes = new ArrayList<Node>();
 
-				if (node.check(event.x(), event.y())) {
-					active = node;
-					node.hover();
+        GlobalEventBus.subscribeAndRegister(
+                Events.WindowEvents.OnMouseMove.class,
+                event -> {
+                    for (int i = 0; i < nodes.size(); i++) {
+                        Node node = nodes.get(i);
 
-					break;
-				}
-			}
-		});
+                        if (node.check(event.x(), event.y())) {
+                            active = node;
+                            node.hover();
 
-		GlobalEventBus.subscribeAndRegister(Events.WindowEvents.OnMouseClick.class, event -> {
-			if (active != null) {
-				active.click();
-			}
-		});
-	}
+                            break;
+                        }
+                    }
+                });
 
-	public void cleanup() {
-	}
+        GlobalEventBus.subscribeAndRegister(
+                Events.WindowEvents.OnMouseClick.class,
+                event -> {
+                    if (active != null) {
+                        active.click();
+                    }
+                });
+    }
 
-	public void add(Node node) {
-		nodes.add(node);
-	}
+    public void cleanup() {}
 
-	public void render() {
-	}
+    public void add(Node node) {
+        nodes.add(node);
+    }
+
+    public void render() {}
 }
diff --git a/src/main/java/org/toop/frontend/graphics/node/Widget.java b/src/main/java/org/toop/frontend/graphics/node/Widget.java
index c63575f..0cb38d8 100644
--- a/src/main/java/org/toop/frontend/graphics/node/Widget.java
+++ b/src/main/java/org/toop/frontend/graphics/node/Widget.java
@@ -1,49 +1,48 @@
 package org.toop.frontend.graphics.node;
 
+import java.util.*;
 import org.toop.frontend.math.Bounds;
 
-import java.util.*;
-
 public class Widget {
-	Bounds bounds;
-	private ArrayList<Node> nodes;
+    Bounds bounds;
+    private ArrayList<Node> nodes;
 
-	public Widget(Bounds bounds) {
-		this.bounds = bounds;
-		nodes = new ArrayList<Node>();
-	}
+    public Widget(Bounds bounds) {
+        this.bounds = bounds;
+        nodes = new ArrayList<Node>();
+    }
 
-	public boolean check(int x, int y) {
-		return bounds.check(x, y);
-	}
+    public boolean check(int x, int y) {
+        return bounds.check(x, y);
+    }
 
-	public void add(Node node) {
-		nodes.add(node);
-	}
+    public void add(Node node) {
+        nodes.add(node);
+    }
 
-	public boolean hover(int x, int y) {
-		for (int i = 0; i < nodes.size(); i++) {
-			Node node = nodes.get(i);
+    public boolean hover(int x, int y) {
+        for (int i = 0; i < nodes.size(); i++) {
+            Node node = nodes.get(i);
 
-			if (node.check(x, y)) {
-				node.hover();
-				return true;
-			}
-		}
+            if (node.check(x, y)) {
+                node.hover();
+                return true;
+            }
+        }
 
-		return false;
-	}
+        return false;
+    }
 
-	public boolean click(int x, int y) {
-		for (int i = 0; i < nodes.size(); i++) {
-			Node node = nodes.get(i);
+    public boolean click(int x, int y) {
+        for (int i = 0; i < nodes.size(); i++) {
+            Node node = nodes.get(i);
 
-			if (node.check(x, y)) {
-				node.click();
-				return true;
-			}
-		}
+            if (node.check(x, y)) {
+                node.click();
+                return true;
+            }
+        }
 
-		return false;
-	}
+        return false;
+    }
 }
diff --git a/src/main/java/org/toop/frontend/math/Bounds.java b/src/main/java/org/toop/frontend/math/Bounds.java
index fdef983..36d0aac 100644
--- a/src/main/java/org/toop/frontend/math/Bounds.java
+++ b/src/main/java/org/toop/frontend/math/Bounds.java
@@ -1,30 +1,39 @@
 package org.toop.frontend.math;
 
 public class Bounds {
-	private int x;
-	private int y;
-	private int width;
-	private int height;
+    private int x;
+    private int y;
+    private int width;
+    private int height;
 
-	public Bounds(int x, int y, int width, int height) {
-		set(x, y, width, height);
-	}
+    public Bounds(int x, int y, int width, int height) {
+        set(x, y, width, height);
+    }
 
-	public void set(int x, int y, int width, int height) {
-		this.x = x;
-		this.y = y;
-		this.width = width;
-		this.height = height;
-	}
+    public void set(int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+    }
 
-	public int getX() { return x; }
-	public int getY() { return y; }
-	public int getWidth() { return width; }
-	public int getHeight() { return height; }
+    public int getX() {
+        return x;
+    }
 
-	public boolean check(int x, int y) {
-		return
-			x >= this.x && x <= this.x + this.width &&
-			y >= this.y && y <= this.y + this.height;
-	}
+    public int getY() {
+        return y;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public boolean check(int x, int y) {
+        return x >= this.x && x <= this.x + this.width && y >= this.y && y <= this.y + this.height;
+    }
 }
diff --git a/src/main/java/org/toop/frontend/math/Color.java b/src/main/java/org/toop/frontend/math/Color.java
index 99823d3..0d61fce 100644
--- a/src/main/java/org/toop/frontend/math/Color.java
+++ b/src/main/java/org/toop/frontend/math/Color.java
@@ -1,17 +1,25 @@
 package org.toop.frontend.math;
 
 public class Color {
-	private float r;
-	private float g;
-	private float b;
+    private float r;
+    private float g;
+    private float b;
 
-	public Color(float r, float g, float b) {
-		this.r = r;
-		this.g = g;
-		this.b = b;
-	}
+    public Color(float r, float g, float b) {
+        this.r = r;
+        this.g = g;
+        this.b = b;
+    }
 
-	public float r() { return r; }
-	public float g() { return g; }
-	public float b() { return b; }
+    public float r() {
+        return r;
+    }
+
+    public float g() {
+        return g;
+    }
+
+    public float b() {
+        return b;
+    }
 }
diff --git a/src/main/java/org/toop/frontend/platform/core/glfw/GlfwWindow.java b/src/main/java/org/toop/frontend/platform/core/glfw/GlfwWindow.java
index 1abc037..05f96ef 100644
--- a/src/main/java/org/toop/frontend/platform/core/glfw/GlfwWindow.java
+++ b/src/main/java/org/toop/frontend/platform/core/glfw/GlfwWindow.java
@@ -1,95 +1,108 @@
 package org.toop.frontend.platform.core.glfw;
 
-import org.toop.core.*;
-import org.toop.eventbus.*;
-
 import org.lwjgl.glfw.*;
 import org.lwjgl.system.*;
+import org.toop.core.*;
+import org.toop.eventbus.*;
 
 public class GlfwWindow extends Window {
-	private long window;
+    private long window;
 
-	public GlfwWindow(String title, Size size) {
-		if (!GLFW.glfwInit()) {
-			logger.fatal("Failed to initialize glfw");
-			return;
-		}
+    public GlfwWindow(String title, Size size) {
+        if (!GLFW.glfwInit()) {
+            logger.fatal("Failed to initialize glfw");
+            return;
+        }
 
-		GLFW.glfwDefaultWindowHints();
-		GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE);
-		GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, GLFW.GLFW_TRUE);
+        GLFW.glfwDefaultWindowHints();
+        GLFW.glfwWindowHint(GLFW.GLFW_VISIBLE, GLFW.GLFW_FALSE);
+        GLFW.glfwWindowHint(GLFW.GLFW_RESIZABLE, GLFW.GLFW_TRUE);
 
-		GLFWVidMode videoMode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor());
+        GLFWVidMode videoMode = GLFW.glfwGetVideoMode(GLFW.glfwGetPrimaryMonitor());
 
-		int width = size.width();
-		int height = size.height();
+        int width = size.width();
+        int height = size.height();
 
-		if (width <= 0 || height <= 0 || width > videoMode.width() || height > videoMode.height()) {
-			width = videoMode.width();
-			height = videoMode.height();
+        if (width <= 0 || height <= 0 || width > videoMode.width() || height > videoMode.height()) {
+            width = videoMode.width();
+            height = videoMode.height();
 
-			GLFW.glfwWindowHint(GLFW.GLFW_MAXIMIZED, GLFW.GLFW_TRUE);
-		}
+            GLFW.glfwWindowHint(GLFW.GLFW_MAXIMIZED, GLFW.GLFW_TRUE);
+        }
 
-		long window = GLFW.glfwCreateWindow(width, height, title, MemoryUtil.NULL, MemoryUtil.NULL);
+        long window = GLFW.glfwCreateWindow(width, height, title, MemoryUtil.NULL, MemoryUtil.NULL);
 
-		if (window == MemoryUtil.NULL) {
-			GLFW.glfwTerminate();
+        if (window == MemoryUtil.NULL) {
+            GLFW.glfwTerminate();
 
-			logger.fatal("Failed to create glfw window");
-			return;
-		}
+            logger.fatal("Failed to create glfw window");
+            return;
+        }
 
-		int[] widthBuffer = new int[1];
-		int[] heightBuffer = new int[1];
-		GLFW.glfwGetWindowSize(window, widthBuffer, heightBuffer);
+        int[] widthBuffer = new int[1];
+        int[] heightBuffer = new int[1];
+        GLFW.glfwGetWindowSize(window, widthBuffer, heightBuffer);
 
-		GLFW.glfwMakeContextCurrent(window);
-		GLFW.glfwSwapInterval(1);
+        GLFW.glfwMakeContextCurrent(window);
+        GLFW.glfwSwapInterval(1);
 
-		GLFW.glfwSetWindowCloseCallback(window, (lwindow) -> {
-			GlobalEventBus.post(new Events.WindowEvents.OnQuitRequested());
-		});
+        GLFW.glfwSetWindowCloseCallback(
+                window,
+                (lwindow) -> {
+                    GlobalEventBus.post(new Events.WindowEvents.OnQuitRequested());
+                });
 
-		GLFW.glfwSetFramebufferSizeCallback(window, (lwindow, lwidth, lheight) -> {
-			GlobalEventBus.post(new Events.WindowEvents.OnResize(new Size(lwidth, lheight)));
-		});
+        GLFW.glfwSetFramebufferSizeCallback(
+                window,
+                (lwindow, lwidth, lheight) -> {
+                    GlobalEventBus.post(
+                            new Events.WindowEvents.OnResize(new Size(lwidth, lheight)));
+                });
 
-		GLFW.glfwSetCursorPosCallback(window, (lwindow, lx, ly) -> {
-			GlobalEventBus.post(new Events.WindowEvents.OnMouseMove((int)lx, (int)ly));
-		});
+        GLFW.glfwSetCursorPosCallback(
+                window,
+                (lwindow, lx, ly) -> {
+                    GlobalEventBus.post(new Events.WindowEvents.OnMouseMove((int) lx, (int) ly));
+                });
 
-		GLFW.glfwSetMouseButtonCallback(window, (lwindow, lbutton, laction, lmods) -> {
-			switch (laction) {
-				case GLFW.GLFW_PRESS:
-					GlobalEventBus.post(new Events.WindowEvents.OnMouseClick(lbutton));
-					break;
+        GLFW.glfwSetMouseButtonCallback(
+                window,
+                (lwindow, lbutton, laction, lmods) -> {
+                    switch (laction) {
+                        case GLFW.GLFW_PRESS:
+                            GlobalEventBus.post(new Events.WindowEvents.OnMouseClick(lbutton));
+                            break;
 
-				case GLFW.GLFW_RELEASE:
-					GlobalEventBus.post(new Events.WindowEvents.OnMouseRelease(lbutton));
-					break;
+                        case GLFW.GLFW_RELEASE:
+                            GlobalEventBus.post(new Events.WindowEvents.OnMouseRelease(lbutton));
+                            break;
 
-				default: break;
-			}
-		});
+                        default:
+                            break;
+                    }
+                });
 
-		this.window = window;
-		GLFW.glfwShowWindow(window);
+        this.window = window;
+        GLFW.glfwShowWindow(window);
 
-		logger.info("Glfw window setup. Title: {}. Width: {}. Height: {}.", title, size.width(), size.height());
-	}
+        logger.info(
+                "Glfw window setup. Title: {}. Width: {}. Height: {}.",
+                title,
+                size.width(),
+                size.height());
+    }
 
-	@Override
-	public void cleanup() {
-		GLFW.glfwDestroyWindow(window);
-		GLFW.glfwTerminate();
+    @Override
+    public void cleanup() {
+        GLFW.glfwDestroyWindow(window);
+        GLFW.glfwTerminate();
 
-		super.cleanup();
-	}
+        super.cleanup();
+    }
 
-	@Override
-	public void update() {
-		GLFW.glfwSwapBuffers(window);
-		GLFW.glfwPollEvents();
-	}
+    @Override
+    public void update() {
+        GLFW.glfwSwapBuffers(window);
+        GLFW.glfwPollEvents();
+    }
 }
diff --git a/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglRenderer.java b/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglRenderer.java
index 53fbc6c..0e587c2 100644
--- a/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglRenderer.java
+++ b/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglRenderer.java
@@ -1,76 +1,78 @@
 package org.toop.frontend.platform.graphics.opengl;
 
+import org.lwjgl.opengl.*;
+import org.lwjgl.system.*;
 import org.toop.eventbus.*;
 import org.toop.frontend.graphics.Renderer;
 import org.toop.frontend.graphics.Shader;
 
-import org.lwjgl.opengl.*;
-import org.lwjgl.system.*;
-
 public class OpenglRenderer extends Renderer {
-	private Shader shader;
-	private int vao;
+    private Shader shader;
+    private int vao;
 
-	public OpenglRenderer() {
-		GL.createCapabilities();
-		GL45.glClearColor(0.65f, 0.9f, 0.65f, 1f);
-		
-		GlobalEventBus.subscribeAndRegister(Events.WindowEvents.OnResize.class, event -> {
-			GL45.glViewport(0, 0, event.size().width(), event.size().height());
-		});
+    public OpenglRenderer() {
+        GL.createCapabilities();
+        GL45.glClearColor(0.65f, 0.9f, 0.65f, 1f);
 
-		logger.info("Opengl renderer setup.");
+        GlobalEventBus.subscribeAndRegister(
+                Events.WindowEvents.OnResize.class,
+                event -> {
+                    GL45.glViewport(0, 0, event.size().width(), event.size().height());
+                });
 
-		// Form here on, everything is temporary
-		float vertices[] = {
-			-0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
-			-0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
-			0.5f, -0.5f, 0.0f, 0.0f, 1.0f,
-			0.5f, 0.5f, 1.0f, 1.0f, 0.0f,
-		};
+        logger.info("Opengl renderer setup.");
 
-		int indicies[] = {
-			0, 1, 2,
-			2, 3, 0,
-		};
+        // Form here on, everything is temporary
+        float vertices[] = {
+            -0.5f, 0.5f, 1.0f, 0.0f, 0.0f,
+            -0.5f, -0.5f, 0.0f, 1.0f, 0.0f,
+            0.5f, -0.5f, 0.0f, 0.0f, 1.0f,
+            0.5f, 0.5f, 1.0f, 1.0f, 0.0f,
+        };
 
-		vao = GL45.glCreateVertexArrays();
-		GL45.glBindVertexArray(vao);
+        int indicies[] = {
+            0, 1, 2,
+            2, 3, 0,
+        };
 
-		int vbo = GL45.glCreateBuffers();
-		GL45.glBindBuffer(GL45.GL_ARRAY_BUFFER, vbo);
-		GL45.glBufferData(GL45.GL_ARRAY_BUFFER, vertices, GL45.GL_STATIC_DRAW);
+        vao = GL45.glCreateVertexArrays();
+        GL45.glBindVertexArray(vao);
 
-		GL45.glVertexAttribPointer(0, 2, GL45.GL_FLOAT, false, 5 * 4, 0);
-		GL45.glVertexAttribPointer(1, 3, GL45.GL_FLOAT, false, 5 * 4, 2 * 4);
+        int vbo = GL45.glCreateBuffers();
+        GL45.glBindBuffer(GL45.GL_ARRAY_BUFFER, vbo);
+        GL45.glBufferData(GL45.GL_ARRAY_BUFFER, vertices, GL45.GL_STATIC_DRAW);
 
-		GL45.glEnableVertexAttribArray(0);
-		GL45.glEnableVertexAttribArray(1);
+        GL45.glVertexAttribPointer(0, 2, GL45.GL_FLOAT, false, 5 * 4, 0);
+        GL45.glVertexAttribPointer(1, 3, GL45.GL_FLOAT, false, 5 * 4, 2 * 4);
 
-		int ib = GL45.glCreateBuffers();
-		GL45.glBindBuffer(GL45.GL_ELEMENT_ARRAY_BUFFER, ib);
-		GL45.glBufferData(GL45.GL_ELEMENT_ARRAY_BUFFER, indicies, GL45.GL_STATIC_DRAW);
+        GL45.glEnableVertexAttribArray(0);
+        GL45.glEnableVertexAttribArray(1);
 
-		shader = Shader.create(
-			"src/main/resources/shaders/gui_vertex.glsl",
-			"src/main/resources/shaders/gui_fragment.glsl");
-	}
+        int ib = GL45.glCreateBuffers();
+        GL45.glBindBuffer(GL45.GL_ELEMENT_ARRAY_BUFFER, ib);
+        GL45.glBufferData(GL45.GL_ELEMENT_ARRAY_BUFFER, indicies, GL45.GL_STATIC_DRAW);
 
-	@Override
-	public void cleanup() {
-		super.cleanup();
-	}
+        shader =
+                Shader.create(
+                        "src/main/resources/shaders/gui_vertex.glsl",
+                        "src/main/resources/shaders/gui_fragment.glsl");
+    }
 
-	@Override
-	public void clear() {
-		GL45.glClear(GL45.GL_COLOR_BUFFER_BIT);
-	}
+    @Override
+    public void cleanup() {
+        super.cleanup();
+    }
 
-	@Override
-	public void render() {
-		// temporary
-	//	shader.start();
-		GL45.glBindVertexArray(vao);
-		GL45.glDrawElements(GL45.GL_TRIANGLES, 6, GL45.GL_UNSIGNED_INT, MemoryUtil.NULL);
-	}
+    @Override
+    public void clear() {
+        GL45.glClear(GL45.GL_COLOR_BUFFER_BIT);
+    }
+
+    @Override
+    public void render() {
+        // temporary
+        //	shader.start();
+        GL45.glBindVertexArray(vao);
+        GL45.glDrawElements(GL45.GL_TRIANGLES, 6, GL45.GL_UNSIGNED_INT, MemoryUtil.NULL);
+    }
 }
diff --git a/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglShader.java b/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglShader.java
index bbd686a..b295ec7 100644
--- a/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglShader.java
+++ b/src/main/java/org/toop/frontend/platform/graphics/opengl/OpenglShader.java
@@ -1,58 +1,57 @@
 package org.toop.frontend.platform.graphics.opengl;
 
+import org.lwjgl.opengl.*;
 import org.toop.core.*;
 import org.toop.frontend.graphics.Shader;
 
-import org.lwjgl.opengl.*;
-
 public class OpenglShader extends Shader {
-	private int programID;
+    private int programID;
 
-	public OpenglShader(String vertexPath, String fragmentPath) {
-		FileSystem.File vertexSource = FileSystem.read(vertexPath);
-		FileSystem.File fragmentSource = FileSystem.read(fragmentPath);
+    public OpenglShader(String vertexPath, String fragmentPath) {
+        FileSystem.File vertexSource = FileSystem.read(vertexPath);
+        FileSystem.File fragmentSource = FileSystem.read(fragmentPath);
 
-		if (vertexSource == null || fragmentPath == null) {
-			return;
-		}
+        if (vertexSource == null || fragmentPath == null) {
+            return;
+        }
 
-		programID = GL45.glCreateProgram();
+        programID = GL45.glCreateProgram();
 
-		int vertexShader = GL45.glCreateShader(GL45.GL_VERTEX_SHADER);
-		int fragmentShader = GL45.glCreateShader(GL45.GL_FRAGMENT_SHADER);
+        int vertexShader = GL45.glCreateShader(GL45.GL_VERTEX_SHADER);
+        int fragmentShader = GL45.glCreateShader(GL45.GL_FRAGMENT_SHADER);
 
-		GL45.glShaderSource(vertexShader, vertexSource.buffer());
-		GL45.glShaderSource(fragmentShader, fragmentSource.buffer());
+        GL45.glShaderSource(vertexShader, vertexSource.buffer());
+        GL45.glShaderSource(fragmentShader, fragmentSource.buffer());
 
-		GL45.glCompileShader(vertexShader);
-		GL45.glCompileShader(fragmentShader);
+        GL45.glCompileShader(vertexShader);
+        GL45.glCompileShader(fragmentShader);
 
-		GL45.glAttachShader(programID, vertexShader);
-		GL45.glAttachShader(programID, fragmentShader);
+        GL45.glAttachShader(programID, vertexShader);
+        GL45.glAttachShader(programID, fragmentShader);
 
-		GL45.glLinkProgram(programID);
-		GL45.glValidateProgram(programID);
+        GL45.glLinkProgram(programID);
+        GL45.glValidateProgram(programID);
 
-		GL45.glDetachShader(programID, vertexShader);
-		GL45.glDetachShader(programID, fragmentShader);
+        GL45.glDetachShader(programID, vertexShader);
+        GL45.glDetachShader(programID, fragmentShader);
 
-		GL45.glDeleteShader(vertexShader);
-		GL45.glDeleteShader(fragmentShader);
-	}
+        GL45.glDeleteShader(vertexShader);
+        GL45.glDeleteShader(fragmentShader);
+    }
 
-	@Override
-	public void cleanup() {
-		stop();
-		GL45.glDeleteProgram(programID);
-	}
+    @Override
+    public void cleanup() {
+        stop();
+        GL45.glDeleteProgram(programID);
+    }
 
-	@Override
-	public void start() {
-		GL45.glUseProgram(programID);
-	}
+    @Override
+    public void start() {
+        GL45.glUseProgram(programID);
+    }
 
-	@Override
-	public void stop() {
-		GL45.glUseProgram(0);
-	}
+    @Override
+    public void stop() {
+        GL45.glUseProgram(0);
+    }
 }
diff --git a/src/main/java/org/toop/game/GameBase.java b/src/main/java/org/toop/game/GameBase.java
index 4a2dcca..099a70d 100644
--- a/src/main/java/org/toop/game/GameBase.java
+++ b/src/main/java/org/toop/game/GameBase.java
@@ -1,46 +1,56 @@
 package org.toop.game;
 
 public abstract class GameBase {
-	public enum State {
-		INVALID,
+    public enum State {
+        INVALID,
 
-		NORMAL,
-		DRAW,
-		WIN,
-	}
+        NORMAL,
+        DRAW,
+        WIN,
+    }
 
-	public static char EMPTY = '-';
+    public static char EMPTY = '-';
 
-	protected int size;
-	public char[] grid;
+    protected int size;
+    public char[] grid;
 
-	protected Player[] players;
-	public int currentPlayer;
+    protected Player[] players;
+    public int currentPlayer;
 
-	public GameBase(int size, Player player1, Player player2) {
-		this.size = size;
-		grid = new char[size * size];
+    public GameBase(int size, Player player1, Player player2) {
+        this.size = size;
+        grid = new char[size * size];
 
-		for (int i = 0; i < grid.length; i++) {
-			grid[i] = EMPTY;
-		}
+        for (int i = 0; i < grid.length; i++) {
+            grid[i] = EMPTY;
+        }
 
-		players = new Player[2];
-		players[0] = player1;
-		players[1] = player2;
+        players = new Player[2];
+        players[0] = player1;
+        players[1] = player2;
 
-		currentPlayer = 0;
-	}
+        currentPlayer = 0;
+    }
 
-	public boolean isInside(int index) {
-		return index >= 0 && index < size * size;
-	}
+    public boolean isInside(int index) {
+        return index >= 0 && index < size * size;
+    }
 
-	public int getSize() { return size; }
-	public char[] getGrid() { return grid; }
+    public int getSize() {
+        return size;
+    }
 
-	public Player[] getPlayers() { return players; }
-	public Player getCurrentPlayer() { return players[currentPlayer]; }
+    public char[] getGrid() {
+        return grid;
+    }
 
-	public abstract State play(int index);
+    public Player[] getPlayers() {
+        return players;
+    }
+
+    public Player getCurrentPlayer() {
+        return players[currentPlayer];
+    }
+
+    public abstract State play(int index);
 }
diff --git a/src/main/java/org/toop/game/tictactoe/MinMaxTicTacToe.java b/src/main/java/org/toop/game/tictactoe/MinMaxTicTacToe.java
index 50c9051..a8dc2e1 100644
--- a/src/main/java/org/toop/game/tictactoe/MinMaxTicTacToe.java
+++ b/src/main/java/org/toop/game/tictactoe/MinMaxTicTacToe.java
@@ -1,18 +1,17 @@
 package org.toop.game.tictactoe;
 
-import org.toop.game.*;
-
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import org.toop.game.*;
 
 public class MinMaxTicTacToe {
 
     private static final Logger logger = LogManager.getLogger(MinMaxTicTacToe.class);
 
     /**
-     * This method tries to find the best move by seeing if it can set a winning move, if not, it will do a minimax.
+     * This method tries to find the best move by seeing if it can set a winning move, if not, it
+     * will do a minimax.
      */
-
     public int findBestMove(TicTacToe game) {
         int bestVal = -100; // set bestval to something impossible
         int bestMove = 10; // set bestmove to something impossible
@@ -21,7 +20,7 @@ public class MinMaxTicTacToe {
 
         boolean empty = true;
         for (char cell : game.grid) {
-            if(!(cell == GameBase.EMPTY)) {
+            if (!(cell == GameBase.EMPTY)) {
                 empty = false;
                 break;
             }
@@ -34,8 +33,7 @@ public class MinMaxTicTacToe {
         // simulate all possible moves on the field
         for (int i = 0; i < game.grid.length; i++) {
 
-
-            if (game.validateMove(i)) {  // check if the move is legal here
+            if (game.validateMove(i)) { // check if the move is legal here
                 TicTacToe copyGame = game.copyBoard(); // make a copy of the game
                 GameBase.State result = copyGame.play(i); // play a move on the copy board
 
@@ -45,7 +43,7 @@ public class MinMaxTicTacToe {
                     return i; // just return right away if you can win on the next move
                 }
 
-                for (int index = 0; index < game.grid.length; index++ ) {
+                for (int index = 0; index < game.grid.length; index++) {
                     if (game.validateMove(index)) {
                         TicTacToe opponentCopy = copyGame.copyBoard();
                         GameBase.State opponentResult = opponentCopy.play(index);
@@ -55,8 +53,10 @@ public class MinMaxTicTacToe {
                     }
                 }
 
-                thisMoveValue = doMinimax(copyGame, game.movesLeft, false); // else look at other moves
-                if (thisMoveValue > bestVal) { // if better move than the current best, change the move
+                thisMoveValue =
+                        doMinimax(copyGame, game.movesLeft, false); // else look at other moves
+                if (thisMoveValue
+                        > bestVal) { // if better move than the current best, change the move
                     bestVal = thisMoveValue;
                     bestMove = i;
                 }
@@ -69,31 +69,35 @@ public class MinMaxTicTacToe {
     }
 
     /**
-     * This method simulates all the possible future moves in the game through a copy in search of the best move.
+     * This method simulates all the possible future moves in the game through a copy in search of
+     * the best move.
      */
-
     public int doMinimax(TicTacToe game, int depth, boolean maximizing) {
         boolean state = game.checkWin(); // check for a win (base case stuff)
 
         if (state) {
             if (maximizing) {
-                // it's the maximizing players turn and someone has won. this is not good, so return a negative value
+                // it's the maximizing players turn and someone has won. this is not good, so return
+                // a negative value
                 return -10 + depth;
             } else {
-                // it is the turn of the AI and it has won! this is good for us, so return a positive value above 0
+                // it is the turn of the AI and it has won! this is good for us, so return a
+                // positive value above 0
                 return 10 - depth;
             }
-        }
-
-        else {
+        } else {
             boolean empty = false;
-            for (char cell : game.grid) { // else, look at draw conditions. we check per cell if it's empty or not
+            for (char cell :
+                    game.grid) { // else, look at draw conditions. we check per cell if it's empty
+                // or not
                 if (cell == GameBase.EMPTY) {
                     empty = true; // if a thing is empty, set to true
                     break; // break the loop
                 }
             }
-            if (!empty || depth == 0) { // if the grid is full or the depth is 0 (both meaning game is over) return 0 for draw
+            if (!empty
+                    || depth == 0) { // if the grid is full or the depth is 0 (both meaning game is
+                // over) return 0 for draw
                 return 0;
             }
         }
@@ -104,21 +108,28 @@ public class MinMaxTicTacToe {
                 if (game.validateMove(i)) {
                     TicTacToe copyGame = game.copyBoard();
                     copyGame.play(i); // play the move on a copy board
-                    int value = doMinimax(copyGame, depth - 1, false); // keep going with the minimax
-                    bestVal = Math.max(bestVal, value); // select the best value for the maximizing player (the AI)
+                    int value =
+                            doMinimax(copyGame, depth - 1, false); // keep going with the minimax
+                    bestVal =
+                            Math.max(
+                                    bestVal,
+                                    value); // select the best value for the maximizing player (the
+                    // AI)
                 }
             }
             return bestVal;
-        }
-
-        else { // it's the minimizing players turn, the player
+        } else { // it's the minimizing players turn, the player
             int bestVal = 100; // set the value to the highest possible
             for (int i = 0; i < game.grid.length; i++) { // loop through the grid
                 if (game.validateMove(i)) {
                     TicTacToe copyGame = game.copyBoard();
                     copyGame.play(i); // play the move on a copy board
                     int value = doMinimax(copyGame, depth - 1, true); // keep minimaxing
-                    bestVal = Math.min(bestVal, value); // select the lowest score for the minimizing player, they want to make it hard for us
+                    bestVal =
+                            Math.min(
+                                    bestVal,
+                                    value); // select the lowest score for the minimizing player,
+                    // they want to make it hard for us
                 }
             }
             return bestVal;
diff --git a/src/main/java/org/toop/game/tictactoe/TicTacToe.java b/src/main/java/org/toop/game/tictactoe/TicTacToe.java
index 17881d9..d1f54d5 100644
--- a/src/main/java/org/toop/game/tictactoe/TicTacToe.java
+++ b/src/main/java/org/toop/game/tictactoe/TicTacToe.java
@@ -1,48 +1,45 @@
 package org.toop.game.tictactoe;
 
+import java.util.concurrent.BlockingQueue;
+import java.util.concurrent.LinkedBlockingQueue;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.toop.backend.tictactoe.ParsedCommand;
 import org.toop.backend.tictactoe.TicTacToeServerCommand;
 import org.toop.game.*;
 
-import java.util.concurrent.BlockingQueue;
-import java.util.concurrent.LinkedBlockingQueue;
-
 public class TicTacToe extends GameBase implements Runnable {
 
-	protected static final Logger logger = LogManager.getLogger(TicTacToe.class);
+    protected static final Logger logger = LogManager.getLogger(TicTacToe.class);
 
-	public Thread gameThread;
-	public String gameId;
-	public BlockingQueue<ParsedCommand> commandQueue = new LinkedBlockingQueue<>();
-	public BlockingQueue<String> sendQueue = new LinkedBlockingQueue<>();
+    public Thread gameThread;
+    public String gameId;
+    public BlockingQueue<ParsedCommand> commandQueue = new LinkedBlockingQueue<>();
+    public BlockingQueue<String> sendQueue = new LinkedBlockingQueue<>();
 
-	public int movesLeft;
+    public int movesLeft;
 
-	public TicTacToe(String player1, String player2) {
-		super(3, new Player(player1, 'X'), new Player(player2, 'O'));
-		movesLeft = size * size;
-	}
+    public TicTacToe(String player1, String player2) {
+        super(3, new Player(player1, 'X'), new Player(player2, 'O'));
+        movesLeft = size * size;
+    }
 
-	/**
-	 *
-	 * Used for the server.
-	 *
-	 * @param player1
-	 * @param player2
-	 * @param gameId
-	 */
-	public TicTacToe(String player1, String player2, String gameId) {
-		super(3, new Player(player1, 'X'), new Player(player2, 'O'));
-		this.gameId = gameId;
-		movesLeft = size * size;
-	}
+    /**
+     * Used for the server.
+     *
+     * @param player1
+     * @param player2
+     * @param gameId
+     */
+    public TicTacToe(String player1, String player2, String gameId) {
+        super(3, new Player(player1, 'X'), new Player(player2, 'O'));
+        this.gameId = gameId;
+        movesLeft = size * size;
+    }
 
-
-	public void addCommandToQueue(ParsedCommand command) {
-		commandQueue.add(command);
-	}
+    public void addCommandToQueue(ParsedCommand command) {
+        commandQueue.add(command);
+    }
 
     private ParsedCommand takeFromCommandQueue() {
         try {
@@ -53,165 +50,174 @@ public class TicTacToe extends GameBase implements Runnable {
         }
     }
 
-	private void addSendToQueue(String send) {
+    private void addSendToQueue(String send) {
         try {
             sendQueue.put(send);
         } catch (InterruptedException e) {
             logger.error("Sending to queue interrupted, in game with id: {}", this.gameId);
         }
-	}
+    }
 
-	@Override
-	public void run() {
-		this.gameThread = new Thread(this::gameThread);
-		this.gameThread.start();
-	}
+    @Override
+    public void run() {
+        this.gameThread = new Thread(this::gameThread);
+        this.gameThread.start();
+    }
 
-	private void gameThread() {
+    private void gameThread() {
         boolean running = true;
 
-		while (running) {
+        while (running) {
             ParsedCommand cmd = takeFromCommandQueue();
 
             // Get next command if there was no command
-            if (cmd == null){
+            if (cmd == null) {
                 continue;
             }
 
             // Do something based which command was given
             switch (cmd.command) {
-                case TicTacToeServerCommand.MOVE:{
-                    // TODO: Check if it is this player's turn, not required for local play (I think?).
+                case TicTacToeServerCommand.MOVE:
+                    {
+                        // TODO: Check if it is this player's turn, not required for local play (I
+                        // think?).
 
-                    // Convert given argument to integer
-                    Object arg = cmd.arguments.getFirst();
-                    int index;
-                    try{
-                        index = Integer.parseInt((String)arg);
-                    }
-                    catch (Exception e){
-                        logger.error("Error parsing argument to String or Integer");
-                        continue;
-                    }
-
-                    // Attempt to play the move
-                    State state = play(index);
-
-                    if (state != State.INVALID){
-                        // Tell all players who made a move and what move was made
-                        // TODO: What is the reaction of the game? WIN, DRAW etc?
-                        String player = getCurrentPlayer().name();
-                        addSendToQueue("SVR GAME MOVE {PLAYER: \"" +
-                                player +
-                                "\", DETAILS: \"<reactie spel op zet>\",MOVE: \"" +
-                                index +
-                                "\"}\n");
-                    }
-
-                    // Check move result
-                    switch (state){
-                        case State.WIN:{
-                            // Win
-                            running = false;
-                            addSendToQueue("SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"" +
-                                    "<score speler2>\", COMMENT: \"<commentaar op resultaat>\"}\n");
-                            break;
+                        // Convert given argument to integer
+                        Object arg = cmd.arguments.getFirst();
+                        int index;
+                        try {
+                            index = Integer.parseInt((String) arg);
+                        } catch (Exception e) {
+                            logger.error("Error parsing argument to String or Integer");
+                            continue;
                         }
-                        case State.DRAW:{
-                            // Draw
-                            running = false;
-                            addSendToQueue("SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\", PLAYERTWOSCORE: \"" +
-                                    "<score speler2>\", COMMENT: \"<commentaar op resultaat>\"}\n");
-                            break;
+
+                        // Attempt to play the move
+                        State state = play(index);
+
+                        if (state != State.INVALID) {
+                            // Tell all players who made a move and what move was made
+                            // TODO: What is the reaction of the game? WIN, DRAW etc?
+                            String player = getCurrentPlayer().name();
+                            addSendToQueue(
+                                    "SVR GAME MOVE {PLAYER: \""
+                                            + player
+                                            + "\", DETAILS: \"<reactie spel op zet>\",MOVE: \""
+                                            + index
+                                            + "\"}\n");
                         }
-                        case State.NORMAL:{
-                            // Valid move but not end of game
-                            addSendToQueue("SVR GAME YOURTURN");
-                            break;
-                        }
-                        case State.INVALID:{
-                            // Invalid move
-                            break;
+
+                        // Check move result
+                        switch (state) {
+                            case State.WIN:
+                                {
+                                    // Win
+                                    running = false;
+                                    addSendToQueue(
+                                            "SVR GAME WIN {PLAYERONESCORE: \"<score speler1>\","
+                                                + " PLAYERTWOSCORE: \"<score speler2>\", COMMENT:"
+                                                + " \"<commentaar op resultaat>\"}\n");
+                                    break;
+                                }
+                            case State.DRAW:
+                                {
+                                    // Draw
+                                    running = false;
+                                    addSendToQueue(
+                                            "SVR GAME DRAW {PLAYERONESCORE: \"<score speler1>\","
+                                                + " PLAYERTWOSCORE: \"<score speler2>\", COMMENT:"
+                                                + " \"<commentaar op resultaat>\"}\n");
+                                    break;
+                                }
+                            case State.NORMAL:
+                                {
+                                    // Valid move but not end of game
+                                    addSendToQueue("SVR GAME YOURTURN");
+                                    break;
+                                }
+                            case State.INVALID:
+                                {
+                                    // Invalid move
+                                    break;
+                                }
                         }
                     }
-                }
             }
-		}
+        }
+    }
 
-	}
+    @Override
+    public State play(int index) {
+        if (!validateMove(index)) {
+            return State.INVALID;
+        }
 
-	@Override
-	public State play(int index) {
-		if (!validateMove(index)) {
-			return State.INVALID;
-		}
+        grid[index] = getCurrentPlayer().move();
+        movesLeft--;
 
-		grid[index] = getCurrentPlayer().move();
-		movesLeft--;
+        if (checkWin()) {
+            return State.WIN;
+        }
 
-		if (checkWin()) {
-			return State.WIN;
-		}
+        if (movesLeft <= 0) {
+            return State.DRAW;
+        }
 
-		if (movesLeft <= 0) {
-			return State.DRAW;
-		}
+        currentPlayer = (currentPlayer + 1) % players.length;
+        return State.NORMAL;
+    }
 
-		currentPlayer = (currentPlayer + 1) % players.length;
-		return State.NORMAL;
-	}
+    public boolean validateMove(int index) {
+        return movesLeft > 0 && isInside(index) && grid[index] == EMPTY;
+    }
 
-	public boolean validateMove(int index) {
-		return movesLeft > 0 && isInside(index) && grid[index] == EMPTY;
-	}
+    public boolean checkWin() {
+        // Horizontal
+        for (int i = 0; i < 3; i++) {
+            final int index = i * 3;
 
-	public boolean checkWin() {
-		// Horizontal
-		for (int i = 0; i < 3; i++) {
-			final int index = i * 3;
+            if (grid[index] != EMPTY
+                    && grid[index] == grid[index + 1]
+                    && grid[index] == grid[index + 2]) {
+                return true;
+            }
+        }
 
-			if (grid[index] != EMPTY && grid[index] == grid[index + 1] && grid[index] == grid[index + 2]) {
-				return true;
-			}
-		}
+        // Vertical
+        for (int i = 0; i < 3; i++) {
+            int index = i;
 
-		// Vertical
-		for (int i = 0; i < 3; i++) {
-			int index = i;
+            if (grid[index] != EMPTY
+                    && grid[index] == grid[index + 3]
+                    && grid[index] == grid[index + 6]) {
+                return true;
+            }
+        }
 
-			if (grid[index] != EMPTY && grid[index] == grid[index + 3] && grid[index] == grid[index + 6]) {
-				return true;
-			}
-		}
+        // B-Slash
+        if (grid[0] != EMPTY && grid[0] == grid[4] && grid[0] == grid[8]) {
+            return true;
+        }
 
-		// B-Slash
-		if (grid[0] != EMPTY && grid[0] == grid[4] && grid[0] == grid[8]) {
-			return true;
-		}
+        // F-Slash
+        if (grid[2] != EMPTY && grid[2] == grid[4] && grid[2] == grid[6]) {
+            return true;
+        }
 
-		// F-Slash
-		if (grid[2] != EMPTY && grid[2] == grid[4] && grid[2] == grid[6]) {
-			return true;
-		}
+        return false;
+    }
 
-		return false;
-	}
+    /** For AI use only. */
+    public void decrementMovesLeft() {
+        movesLeft--;
+    }
 
-	/**
-	 * For AI use only.
-	 */
-	public void decrementMovesLeft() {
-		movesLeft--;
-	}
-
-	/**
-	 * This method copies the board, mainly for AI use.
-	 */
-	public TicTacToe copyBoard() {
-		TicTacToe clone = new TicTacToe(players[0].name(), players[1].name());
-		System.arraycopy(this.grid, 0, clone.grid, 0, this.grid.length);
-		clone.movesLeft = this.movesLeft;
-		clone.currentPlayer = this.currentPlayer;
-		return clone;
-	}
+    /** This method copies the board, mainly for AI use. */
+    public TicTacToe copyBoard() {
+        TicTacToe clone = new TicTacToe(players[0].name(), players[1].name());
+        System.arraycopy(this.grid, 0, clone.grid, 0, this.grid.length);
+        clone.movesLeft = this.movesLeft;
+        clone.currentPlayer = this.currentPlayer;
+        return clone;
+    }
 }
diff --git a/src/test/java/GlobalEventBusTest.java b/src/test/java/GlobalEventBusTest.java
index 70ed85a..850f862 100644
--- a/src/test/java/GlobalEventBusTest.java
+++ b/src/test/java/GlobalEventBusTest.java
@@ -1,14 +1,13 @@
+import static org.junit.jupiter.api.Assertions.*;
+
+import java.util.concurrent.atomic.AtomicBoolean;
+import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.toop.eventbus.EventMeta;
 import org.toop.eventbus.EventRegistry;
 import org.toop.eventbus.GlobalEventBus;
 
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static org.junit.jupiter.api.Assertions.*;
-
 public class GlobalEventBusTest {
 
     // Sample event class
@@ -22,7 +21,6 @@ public class GlobalEventBusTest {
         public String getMessage() {
             return message;
         }
-
     }
 
     @BeforeEach
@@ -36,10 +34,13 @@ public class GlobalEventBusTest {
         AtomicReference<String> receivedMessage = new AtomicReference<>();
 
         // Subscribe and register listener
-        EventMeta<TestEvent> meta = GlobalEventBus.subscribeAndRegister(TestEvent.class, e -> {
-            called.set(true);
-            receivedMessage.set(e.getMessage());
-        });
+        EventMeta<TestEvent> meta =
+                GlobalEventBus.subscribeAndRegister(
+                        TestEvent.class,
+                        e -> {
+                            called.set(true);
+                            receivedMessage.set(e.getMessage());
+                        });
 
         assertTrue(EventRegistry.isReady(TestEvent.class));
         assertTrue(meta.isReady());
@@ -49,7 +50,10 @@ public class GlobalEventBusTest {
         GlobalEventBus.post(event);
 
         // Give Guava EventBus a moment (optional if single-threaded)
-        try { Thread.sleep(50); } catch (InterruptedException ignored) {}
+        try {
+            Thread.sleep(50);
+        } catch (InterruptedException ignored) {
+        }
 
         assertTrue(called.get());
         assertEquals("Hello World", receivedMessage.get());
@@ -59,7 +63,8 @@ public class GlobalEventBusTest {
     public void testUnregister() {
         AtomicBoolean called = new AtomicBoolean(false);
 
-        EventMeta<TestEvent> meta = GlobalEventBus.subscribeAndRegister(TestEvent.class, e -> called.set(true));
+        EventMeta<TestEvent> meta =
+                GlobalEventBus.subscribeAndRegister(TestEvent.class, e -> called.set(true));
         assertTrue(meta.isReady());
         assertTrue(EventRegistry.isReady(TestEvent.class));
 
@@ -71,7 +76,10 @@ public class GlobalEventBusTest {
 
         // Post event — listener should NOT be called
         GlobalEventBus.post(new TestEvent("Test"));
-        try { Thread.sleep(50); } catch (InterruptedException ignored) {}
+        try {
+            Thread.sleep(50);
+        } catch (InterruptedException ignored) {
+        }
 
         assertFalse(called.get());
     }
@@ -81,34 +89,43 @@ public class GlobalEventBusTest {
         AtomicBoolean listener1Called = new AtomicBoolean(false);
         AtomicBoolean listener2Called = new AtomicBoolean(false);
 
-        EventMeta<TestEvent> l1 = GlobalEventBus.subscribeAndRegister(TestEvent.class, e -> listener1Called.set(true));
-        EventMeta<TestEvent> l2 = GlobalEventBus.subscribeAndRegister(TestEvent.class, e -> listener2Called.set(true));
+        EventMeta<TestEvent> l1 =
+                GlobalEventBus.subscribeAndRegister(
+                        TestEvent.class, e -> listener1Called.set(true));
+        EventMeta<TestEvent> l2 =
+                GlobalEventBus.subscribeAndRegister(
+                        TestEvent.class, e -> listener2Called.set(true));
 
         GlobalEventBus.post(new TestEvent("Event"));
 
-        try { Thread.sleep(50); } catch (InterruptedException ignored) {}
+        try {
+            Thread.sleep(50);
+        } catch (InterruptedException ignored) {
+        }
 
         assertTrue(listener1Called.get());
         assertTrue(listener2Called.get());
     }
 
     // TODO: Fix registry
-//    @Test
-//    public void testEventStoredInRegistry() {
-//        // Subscribe listener (marks type ready)
-//        EventMeta<TestEvent> meta = GlobalEventBus.subscribeAndRegister(TestEvent.class, e -> {});
-//
-//        // Post the event
-//        TestEvent event = new TestEvent("StoreTest");
-//        GlobalEventBus.post(event);
-//
-//        // Retrieve the last stored EventEntry
-//        EventRegistry.EventEntry<TestEvent> storedEntry = EventRegistry.getLastEvent(TestEvent.class);
-//
-//        assertNotNull(storedEntry);
-//
-//        // Compare the inner event
-//        TestEvent storedEvent = storedEntry.getEvent();
-//        assertEquals(event, storedEvent);
-//    }
+    //    @Test
+    //    public void testEventStoredInRegistry() {
+    //        // Subscribe listener (marks type ready)
+    //        EventMeta<TestEvent> meta = GlobalEventBus.subscribeAndRegister(TestEvent.class, e ->
+    // {});
+    //
+    //        // Post the event
+    //        TestEvent event = new TestEvent("StoreTest");
+    //        GlobalEventBus.post(event);
+    //
+    //        // Retrieve the last stored EventEntry
+    //        EventRegistry.EventEntry<TestEvent> storedEntry =
+    // EventRegistry.getLastEvent(TestEvent.class);
+    //
+    //        assertNotNull(storedEntry);
+    //
+    //        // Compare the inner event
+    //        TestEvent storedEvent = storedEntry.getEvent();
+    //        assertEquals(event, storedEvent);
+    //    }
 }
diff --git a/src/test/java/MinMaxTicTacToeTest.java b/src/test/java/MinMaxTicTacToeTest.java
index 3c2669c..4becc7d 100644
--- a/src/test/java/MinMaxTicTacToeTest.java
+++ b/src/test/java/MinMaxTicTacToeTest.java
@@ -1,3 +1,4 @@
+import static org.junit.jupiter.api.Assertions.*;
 
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -5,11 +6,7 @@ import org.toop.game.GameBase;
 import org.toop.game.tictactoe.MinMaxTicTacToe;
 import org.toop.game.tictactoe.TicTacToe;
 
-import static org.junit.jupiter.api.Assertions.*;
-
-/**
- * Unit tests for MinMaxTicTacToe AI.
- */
+/** Unit tests for MinMaxTicTacToe AI. */
 public class MinMaxTicTacToeTest {
 
     private MinMaxTicTacToe ai;
@@ -28,11 +25,18 @@ public class MinMaxTicTacToeTest {
         // X | X | .
         // O | O | .
         // . | . | .
-        game.grid = new char[]{
-                'X', 'X', GameBase.EMPTY,
-                'O', 'O', GameBase.EMPTY,
-                GameBase.EMPTY, GameBase.EMPTY, GameBase.EMPTY
-        };
+        game.grid =
+                new char[] {
+                    'X',
+                    'X',
+                    GameBase.EMPTY,
+                    'O',
+                    'O',
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY
+                };
         game.movesLeft = 4;
 
         int bestMove = ai.findBestMove(game);
@@ -47,11 +51,18 @@ public class MinMaxTicTacToeTest {
         // O | O | .
         // X | . | .
         // . | . | .
-        game.grid = new char[]{
-                'O', 'O', GameBase.EMPTY,
-                'X', GameBase.EMPTY, GameBase.EMPTY,
-                GameBase.EMPTY, GameBase.EMPTY, GameBase.EMPTY
-        };
+        game.grid =
+                new char[] {
+                    'O',
+                    'O',
+                    GameBase.EMPTY,
+                    'X',
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY
+                };
 
         int bestMove = ai.findBestMove(game);
 
@@ -71,11 +82,18 @@ public class MinMaxTicTacToeTest {
     void testDoMinimaxScoresWinPositive() {
         // Simulate a game state where AI has already won
         TicTacToe copy = game.copyBoard();
-        copy.grid = new char[]{
-                'X', 'X', 'X',
-                'O', 'O', GameBase.EMPTY,
-                GameBase.EMPTY, GameBase.EMPTY, GameBase.EMPTY
-        };
+        copy.grid =
+                new char[] {
+                    'X',
+                    'X',
+                    'X',
+                    'O',
+                    'O',
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY
+                };
 
         int score = ai.doMinimax(copy, 5, false);
 
@@ -86,11 +104,18 @@ public class MinMaxTicTacToeTest {
     void testDoMinimaxScoresLossNegative() {
         // Simulate a game state where human has already won
         TicTacToe copy = game.copyBoard();
-        copy.grid = new char[]{
-                'O', 'O', 'O',
-                'X', 'X', GameBase.EMPTY,
-                GameBase.EMPTY, GameBase.EMPTY, GameBase.EMPTY
-        };
+        copy.grid =
+                new char[] {
+                    'O',
+                    'O',
+                    'O',
+                    'X',
+                    'X',
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY,
+                    GameBase.EMPTY
+                };
 
         int score = ai.doMinimax(copy, 5, true);
 
@@ -101,14 +126,15 @@ public class MinMaxTicTacToeTest {
     void testDoMinimaxDrawReturnsZero() {
         // Simulate a draw position
         TicTacToe copy = game.copyBoard();
-        copy.grid = new char[]{
-                'X', 'O', 'X',
-                'X', 'O', 'O',
-                'O', 'X', 'X'
-        };
+        copy.grid =
+                new char[] {
+                    'X', 'O', 'X',
+                    'X', 'O', 'O',
+                    'O', 'X', 'X'
+                };
 
         int score = ai.doMinimax(copy, 0, true);
 
         assertEquals(0, score, "Draw should return 0 score");
     }
-}
\ No newline at end of file
+}
diff --git a/src/test/java/ServerTest.java b/src/test/java/ServerTest.java
index a6bde60..dad567d 100644
--- a/src/test/java/ServerTest.java
+++ b/src/test/java/ServerTest.java
@@ -1,39 +1,39 @@
 // import org.junit.jupiter.api.BeforeEach;
 // import org.junit.jupiter.api.Test;
 // import org.toop.server.Server;
-// 
+//
 // import static org.junit.jupiter.api.Assertions.*;
-// 
+//
 // public class ServerTest {
-// 
+//
 //     private Server server;
-// 
+//
 //     @BeforeEach
 //     public void setUp() {
 //         server = new Server("127.0.0.1", "8080");
 //     }
-// 
+//
 //     @Test
 //     public void testConstructorSetsValues() {
 //         assertEquals("127.0.0.1", server.getIp());
 //         assertEquals("8080", server.getPort());
 //     }
-// 
+//
 //     @Test
 //     public void testSetIpUpdatesValue() {
 //         server.setIp("192.168.1.1");
 //         assertEquals("192.168.1.1", server.getIp());
 //     }
-// 
+//
 //     @Test
 //     public void testSetPortUpdatesValue() {
 //         server.setPort("9090");
 //         assertEquals("9090", server.getPort());
 //     }
-// 
+//
 //     @Test
 //     public void testNotNullAfterConstruction() {
 //         assertNotNull(server);
 //     }
-// 
+//
 // }