.idea/.idea.pac-man-board-game/.idea/codeStyles/codeStyleConfig.xml

@@ -1,5 +1,5 @@
 <component name="ProjectCodeStyleConfiguration">
   <state>
-    <option name="USE_PER_PROJECT_SETTINGS" value="true" />
+    <option name="PREFERRED_PROJECT_CODE_STYLE" value="Default" />
   </state>
 </component>

BackendTests/BackendTests.csproj

@@ -1,28 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
 
         <IsPackable>false</IsPackable>
-
-        <LangVersion>13</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
-        <PackageReference Include="NSubstitute" Version="5.1.0"/>
-        <PackageReference Include="NUnit" Version="4.0.1"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
-        <PackageReference Include="NUnit.Analyzers" Version="3.10.0">
-            <PrivateAssets>all</PrivateAssets>
-            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
-        <PackageReference Include="coverlet.collector" Version="6.0.0">
-            <PrivateAssets>all</PrivateAssets>
-            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
-        </PackageReference>
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+        <PackageReference Include="NSubstitute" Version="5.0.0" />
+        <PackageReference Include="NUnit" Version="3.13.3" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+        <PackageReference Include="NUnit.Analyzers" Version="3.3.0" />
+        <PackageReference Include="coverlet.collector" Version="3.1.2" />
     </ItemGroup>
 
     <ItemGroup>

BackendTests/Controllers/GameControllerTests.cs

@@ -11,10 +11,12 @@ using pacMan.Utils;
 
 namespace BackendTests.Controllers;
 
-[TestFixture]
-[TestOf(nameof(GameController))]
 public class GameControllerTests
 {
+    private IActionService _actionService = null!;
+    private GameController _controller = null!;
+    private GameService _gameService = null!;
+
     [SetUp]
     public void Setup()
     {
@@ -25,10 +27,6 @@ public class GameControllerTests
         _controller = new GameController(Substitute.For<ILogger<GameController>>(), _gameService, _actionService);
     }
 
-    private IActionService _actionService = null!;
-    private GameController _controller = null!;
-    private GameService _gameService = null!;
-
     [Test]
     public void Run_ReturnsSame()
     {
@@ -53,22 +51,4 @@ public class GameControllerTests
         else
             Assert.Fail("Result is not an ArraySegment<byte>");
     }
-
-    [Test]
-    public void DoAction_NegativeAction()
-    {
-        const string data = "Nothing happens";
-        var message = new ActionMessage { Action = (GameAction)(-1), Data = data };
-        _controller.DoAction(message);
-        Assert.That(message.Data, Is.EqualTo(data));
-    }
-
-    [Test]
-    public void DoAction_OutOfBoundsAction()
-    {
-        const string data = "Nothing happens";
-        var message = new ActionMessage { Action = (GameAction)100, Data = data };
-        _controller.DoAction(message);
-        Assert.That(message.Data, Is.EqualTo(data));
-    }
 }

BackendTests/Controllers/PlayerControllerTests.cs

@@ -1,9 +1,5 @@
-using pacMan.Controllers;
-
 namespace BackendTests.Controllers;
 
-[TestFixture]
-[TestOf(nameof(PlayerController))]
 public class PlayerControllerTests
 {
     // TODO

BackendTests/Game/Items/DiceCupTests.cs

@@ -2,8 +2,6 @@ using pacMan.GameStuff.Items;
 
 namespace BackendTests.Game.Items;
 
-[TestFixture]
-[TestOf(nameof(DiceCup))]
 public class DiceCupTests
 {
     [Test]

BackendTests/Game/Items/DiceTests.cs

@@ -2,8 +2,6 @@ using pacMan.GameStuff.Items;
 
 namespace BackendTests.Game.Items;
 
-[TestFixture]
-[TestOf(nameof(Dice))]
 public class DiceTests
 {
     [Test]

BackendTests/Services/ActionServiceTests.cs

@@ -2,7 +2,6 @@ using System.Text.Json;
 using BackendTests.TestUtils;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
-using pacMan.DTOs;
 using pacMan.Exceptions;
 using pacMan.GameStuff;
 using pacMan.GameStuff.Items;
@@ -10,21 +9,8 @@ using pacMan.Services;
 
 namespace BackendTests.Services;
 
-[TestFixture, TestOf(nameof(ActionService))]
 public class ActionServiceTests
 {
-    [SetUp]
-    public void Setup()
-    {
-        _spawns = CreateQueue();
-        _game = new pacMan.Services.Game(_spawns);
-        _whiteMessage = new ActionMessage { Action = GameAction.JoinGame, Data = SerializeData(_whitePlayer.Username) };
-        _blackMessage = new ActionMessage { Action = GameAction.JoinGame, Data = SerializeData(_blackPlayer.Username) };
-        _redMessage = new ActionMessage { Action = GameAction.JoinGame, Data = SerializeData(_redPlayer.Username) };
-        _gameService = Substitute.For<GameService>(Substitute.For<ILogger<GameService>>());
-        _service = new ActionService(Substitute.For<ILogger<ActionService>>(), _gameService);
-    }
-
     private readonly Player _blackPlayer = Players.Create("black");
     private readonly Player _redPlayer = Players.Create("red");
     private readonly Player _whitePlayer = Players.Create("white");
@@ -37,6 +23,19 @@ public class ActionServiceTests
     private Queue<DirectionalPosition> _spawns = null!;
     private ActionMessage _whiteMessage = null!;
 
+
+    [SetUp]
+    public void Setup()
+    {
+        _spawns = CreateQueue();
+        _game = new pacMan.Services.Game(_spawns);
+        _whiteMessage = new ActionMessage { Action = GameAction.JoinGame, Data = SerializeData(_whitePlayer.Username) };
+        _blackMessage = new ActionMessage { Action = GameAction.JoinGame, Data = SerializeData(_blackPlayer.Username) };
+        _redMessage = new ActionMessage { Action = GameAction.JoinGame, Data = SerializeData(_redPlayer.Username) };
+        _gameService = Substitute.For<GameService>(Substitute.For<ILogger<GameService>>());
+        _service = new ActionService(Substitute.For<ILogger<ActionService>>(), _gameService);
+    }
+
     private JsonElement SerializeData(string username) =>
         JsonDocument.Parse(JsonSerializer.Serialize(
             new JoinGameData { Username = username, GameId = _game.Id }
@@ -51,6 +50,8 @@ public class ActionServiceTests
             new() { At = new Position { X = 9, Y = 9 }, Direction = Direction.Right }
         });
 
+    #region RollDice()
+
     [Test]
     public void RollDice_ReturnsListOfIntegers()
     {
@@ -63,6 +64,10 @@ public class ActionServiceTests
         });
     }
 
+    #endregion
+
+    #region PlayerInfo(ActionMessage message)
+
     [Test]
     public void PlayerInfo_DataIsNull()
     {
@@ -92,6 +97,32 @@ public class ActionServiceTests
         Assert.That(new List<Player> { _whitePlayer }, Is.EqualTo(players));
     }
 
+    #endregion
+
+    #region DoAction(ActionMessage message)
+
+    [Test]
+    public void DoAction_NegativeAction()
+    {
+        const string data = "Nothing happens";
+        var message = new ActionMessage { Action = (GameAction)(-1), Data = data };
+        _service.DoAction(message);
+        Assert.That(message.Data, Is.EqualTo(data));
+    }
+
+    [Test]
+    public void DoAction_OutOfBoundsAction()
+    {
+        const string data = "Nothing happens";
+        var message = new ActionMessage { Action = (GameAction)100, Data = data };
+        _service.DoAction(message);
+        Assert.That(message.Data, Is.EqualTo(data));
+    }
+
+    #endregion
+
+    #region Ready()
+
     [Test]
     public void Ready_PlayerIsNull()
     {
@@ -152,11 +183,15 @@ public class ActionServiceTests
             Is.EqualTo(_blackPlayer.Username).Or.EqualTo(_whitePlayer.Username));
     }
 
+    #endregion
+
+    #region FindNextPlayer()
+
     [Test]
     public void FindNextPlayer_NoPlayers()
     {
         _service.Game = new pacMan.Services.Game(new Queue<DirectionalPosition>());
-        Assert.Throws<PlayerNotFoundException>(() => _service.FindNextPlayer());
+        Assert.Throws<InvalidOperationException>(() => _service.FindNextPlayer());
     }
 
     [Test]
@@ -186,4 +221,6 @@ public class ActionServiceTests
         var second = _service.FindNextPlayer();
         Assert.That(second, Is.EqualTo(_whitePlayer.Username));
     }
+
+    #endregion
 }

BackendTests/Services/GameServiceTests.cs

@@ -3,14 +3,19 @@ using Microsoft.Extensions.Logging;
 using NSubstitute;
 using pacMan.Exceptions;
 using pacMan.GameStuff;
+using pacMan.GameStuff.Items;
 using pacMan.Services;
 
 namespace BackendTests.Services;
 
-[TestFixture]
-[TestOf(nameof(GameService))]
 public class GameServiceTests
 {
+    private readonly DirectionalPosition _spawn3By3Up = new()
+        { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
+
+    private GameService _service = null!;
+    private Queue<DirectionalPosition> _spawns = null!;
+
     [SetUp]
     public void SetUp()
     {
@@ -24,11 +29,7 @@ public class GameServiceTests
         });
     }
 
-    private readonly DirectionalPosition _spawn3By3Up = new()
-        { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
-
-    private GameService _service = null!;
-    private Queue<DirectionalPosition> _spawns = null!;
+    #region CreateAndJoin(IPlayer player, Queue<DirectionalPosition> spawns)
 
     [Test]
     public void CreateAndJoin_WhenEmpty()
@@ -52,11 +53,15 @@ public class GameServiceTests
         Assert.Throws<ArgumentException>(() => _service.CreateAndJoin(player, _spawns));
     }
 
+    #endregion
+
+    #region JoinbyId(Guid id)
+
     [Test]
     public void JoinById_WhenIdNotExists()
     {
         var player = Players.Create("white");
-        _service.Games.Add(new pacMan.Services.Game(_spawns) { Players = [player] });
+        _service.Games.Add(new pacMan.Services.Game(_spawns) { Players = new List<Player> { player } });
 
         Assert.Throws<GameNotFoundException>(() => _service.JoinById(Guid.NewGuid(), player));
     }
@@ -65,7 +70,7 @@ public class GameServiceTests
     public void JoinById_WhenIdExists()
     {
         var player = Players.Create("white");
-        var game = new pacMan.Services.Game(_spawns) { Players = [player] };
+        var game = new pacMan.Services.Game(_spawns) { Players = new List<Player> { player } };
         _service.Games.Add(game);
 
 
@@ -79,4 +84,6 @@ public class GameServiceTests
             Assert.That(_service.Games, Has.Count.EqualTo(1));
         });
     }
+
+    #endregion
 }

BackendTests/Services/GameTests.cs

@@ -6,23 +6,8 @@ using pacMan.Utils;
 
 namespace BackendTests.Services;
 
-[TestFixture, TestOf(nameof(pacMan.Services.Game))]
 public class GameTests
 {
-    [SetUp]
-    public void Setup()
-    {
-        _spawns = new Queue<DirectionalPosition>(
-            new[] { _spawn3By3Up, _spawn7By7Left, _spawn7By7Down, _spawn7By7Right });
-
-        _game = new pacMan.Services.Game(_spawns);
-        _redPlayer = Players.Create("red");
-        _bluePlayer = Players.Create("blue");
-        _yellowPlayer = Players.Create("yellow");
-        _greenPlayer = Players.Create("green");
-        _purplePlayer = Players.Create("purple");
-    }
-
     private readonly DirectionalPosition _spawn3By3Up = new()
         { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
 
@@ -44,6 +29,20 @@ public class GameTests
     private Queue<DirectionalPosition> _spawns = null!;
     private Player _yellowPlayer = null!;
 
+    [SetUp]
+    public void Setup()
+    {
+        _spawns = new Queue<DirectionalPosition>(
+            new[] { _spawn3By3Up, _spawn7By7Left, _spawn7By7Down, _spawn7By7Right });
+
+        _game = new pacMan.Services.Game(_spawns);
+        _redPlayer = Players.Create("red");
+        _bluePlayer = Players.Create("blue");
+        _yellowPlayer = Players.Create("yellow");
+        _greenPlayer = Players.Create("green");
+        _purplePlayer = Players.Create("purple");
+    }
+
     private void AddFullParty()
     {
         _game.AddPlayer(_bluePlayer);
@@ -52,12 +51,18 @@ public class GameTests
         _game.AddPlayer(_greenPlayer);
     }
 
+    #region NextPlayer()
+
     [Test]
     public void NextPlayer_WhenEmpty()
     {
-        Assert.Throws<PlayerNotFoundException>(() => _game.NextPlayer());
+        Assert.Throws<InvalidOperationException>(() => _game.NextPlayer());
     }
 
+    #endregion
+
+    #region IsGameStarted
+
     [Test]
     public void IsGameStarted_WhenEmpty()
     {
@@ -96,6 +101,10 @@ public class GameTests
         Assert.That(_game.IsGameStarted, Is.True);
     }
 
+    #endregion
+
+    #region AddPlayer(Player player)
+
     [Test]
     public void AddPlayer_WhenEmpty()
     {
@@ -148,6 +157,10 @@ public class GameTests
         Assert.Throws<GameNotPlayableException>(() => _game.AddPlayer(_greenPlayer));
     }
 
+    #endregion
+
+    #region Sendtoall(ArraySegment<byte> segment)
+
     [Test]
     public void SendToAll_WhenConnectionsIsNull()
     {
@@ -158,6 +171,7 @@ public class GameTests
     public void SendToAll_WhenConnectionsIsNotNull()
     {
         var counter = 0;
+        async Task Send(ArraySegment<byte> segment) => await Task.Run(() => counter++);
 
         _game.Connections += Send;
         _game.Connections += Send;
@@ -168,11 +182,12 @@ public class GameTests
         while (counter < 2) { }
 
         Assert.That(counter, Is.EqualTo(2));
-        return;
-
-        async Task Send(ArraySegment<byte> segment) => await Task.Run(() => counter++);
     }
 
+    #endregion
+
+    #region SetReady(Player player)
+
     [Test]
     public void SetReady_ReturnsAllPlayers()
     {
@@ -207,6 +222,10 @@ public class GameTests
         Assert.Throws<PlayerNotFoundException>(() => _game.SetReady(_redPlayer.Username));
     }
 
+    #endregion
+
+    #region SetAllIngame()
+
     [Test]
     public void SetAllInGame_SetsStateToInGame()
     {
@@ -238,6 +257,10 @@ public class GameTests
         Assert.That(_game.Players, Is.Empty);
     }
 
+    #endregion
+
+    #region IsGameStarted()
+
     [Test]
     public void IsGameStarted_AllWaiting()
     {
@@ -252,4 +275,6 @@ public class GameTests
         _game.Players.ForEach(player => player.State = State.InGame);
         Assert.That(_game.IsGameStarted, Is.True);
     }
+
+    #endregion
 }

BackendTests/Services/WebSocketServiceTests.cs

@@ -1,22 +1,23 @@
 using System.Net.WebSockets;
 using Microsoft.Extensions.Logging;
 using NSubstitute;
+using pacMan.Interfaces;
 using pacMan.Services;
 using pacMan.Utils;
 
 namespace BackendTests.Services;
 
-[TestFixture]
-[TestOf(nameof(WebSocketService))]
 public class WebSocketServiceTests
 {
+    private IWebSocketService _service = null!;
+
     [SetUp]
     public void SetUp()
     {
         _service = new WebSocketService(Substitute.For<ILogger<WebSocketService>>());
     }
 
-    private IWebSocketService _service = null!;
+    #region Send(Websocket, ArraySegment<byte>)
 
     [Test]
     public void Send_OpenWebsocket()
@@ -47,6 +48,10 @@ public class WebSocketServiceTests
         webSocket.Received().SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None);
     }
 
+    #endregion
+
+    #region Receive(Websocket, byte[])
+
     [Test]
     public void Receive_ExactBuffer()
     {
@@ -85,6 +90,10 @@ public class WebSocketServiceTests
         webSocket.ReceivedWithAnyArgs().ReceiveAsync(default, CancellationToken.None);
     }
 
+    #endregion
+
+    #region Close(Websocket, WebSocketCloseStatus, string?)
+
     [Test]
     public void Close_OpenWebsocket()
     {
@@ -115,4 +124,6 @@ public class WebSocketServiceTests
 
         webSocket.ReceivedWithAnyArgs().CloseAsync(default, default, CancellationToken.None);
     }
+
+    #endregion
 }

BackendTests/Utils/ExtensionsTests.cs

@@ -3,15 +3,9 @@ using pacMan.Utils;
 
 namespace BackendTests.Utils;
 
-[TestFixture]
-[TestOf(nameof(Extensions))]
 public class ExtensionsTests
 {
-    [SetUp]
-    public void Setup()
-    {
-        _bytes = "Hello World!"u8.ToArray();
-    }
+    #region ToArraySegment(this object obj)
 
     [Test]
     public void ToArraySegmentValidObject()
@@ -30,8 +24,18 @@ public class ExtensionsTests
         Assert.That(segment, Has.Count.EqualTo(4));
     }
 
+    #endregion
+
+    #region GetString(this byte[] bytes, int length)
+
     private byte[] _bytes = null!;
 
+    [SetUp]
+    public void Setup()
+    {
+        _bytes = "Hello World!"u8.ToArray();
+    }
+
     [Test]
     public void GetString_ValidByteArray()
     {
@@ -61,4 +65,6 @@ public class ExtensionsTests
     {
         Assert.That(_bytes.GetString(_bytes.Length / 2), Is.EqualTo("Hello "));
     }
+
+    #endregion
 }

DataAccessLayer/DataAccessLayer.csproj

@@ -1,11 +1,10 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
         <RootNamespace>DAL</RootNamespace>
-        <LangVersion>13</LangVersion>
     </PropertyGroup>
 
 </Project>

DataAccessLayer/Database/Service/UserService.cs

@@ -4,8 +4,8 @@ namespace DAL.Database.Service;
 
 public class UserService
 {
-    private readonly List<User> _users =
-    [
+    private readonly List<User> _users = new()
+    {
         new User
         {
             Username = "Firefox",
@@ -18,10 +18,10 @@ public class UserService
             Password = "Chrome",
             Colour = "blue"
         }
-    ];
+    };
 
-    public Task<User?> Login(string username, string password)
+    public async Task<User?> Login(string username, string password)
     {
-        return Task.Run(() => _users.FirstOrDefault(x => x.Username == username && x.Password == password));
+        return await Task.Run(() => _users.FirstOrDefault(x => x.Username == username && x.Password == password));
     }
 }

README.md

@@ -11,11 +11,6 @@ cd ..
 dotnet run
 ```
 
-### Log in
-For testing there are currently two users available:
-- Username: `Firefox`, Password: `Firefox`
-- Username: `Chrome`, Password: `Chrome`
-
 ## Stack
 
 - Frontend

pac-man-board-game.sln.DotSettings.user

@@ -1,6 +1,4 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
-	<s:Boolean x:Key="/Default/Dpa/ExcludeFilters/=_002A_003B_002A_003BpacMan_002EControllers_002EGameController_003BConnect/@EntryIndexedValue">True</s:Boolean>
-	<s:Boolean x:Key="/Default/Environment/UnitTesting/CreateUnitTestDialog/ShowAdvancedOptions/@EntryValue">True</s:Boolean>
-	<s:String x:Key="/Default/Environment/UnitTesting/CreateUnitTestDialog/TestProjectMapping/=60072632_002DA16F_002D4007_002D8A97_002DAC74B7E6703B/@EntryIndexedValue">35336347-32EB-4764-A28E-3F8FF6CA54C4</s:String>
-	<s:String x:Key="/Default/Environment/UnitTesting/CreateUnitTestDialog/TestTemplateMapping/=NUnit3x/@EntryIndexedValue">db4927dd-2e12-48a7-9a84-2b7e3e31b9c8</s:String>
-	</wpf:ResourceDictionary>
+	<s:String x:Key="/Default/Environment/UnitTesting/UnitTestSessionStore/Sessions/=4f001339_002D2d48_002D46c8_002D91bc_002D45608c0ab446/@EntryIndexedValue">&lt;SessionState ContinuousTestingMode="0" IsActive="True" Name="All tests from &amp;lt;BackendTests&amp;gt;" xmlns="urn:schemas-jetbrains-com:jetbrains-ut-session"&gt;
+  &lt;Project Location="/home/martin/Git/Csharp/pac-man-board-game/BackendTests" Presentation="&amp;lt;BackendTests&amp;gt;" /&gt;
+&lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>

pac-man-board-game/ClientApp/.prettierrc.json

@@ -1,9 +0,0 @@
-{
-  "tabWidth": 2,
-  "semi": false,
-  "singleQuote": false,
-  "arrowParens": "avoid",
-  "bracketSpacing": true,
-  "bracketSameLine": true,
-  "printWidth": 120
-}

pac-man-board-game/ClientApp/package.json

@@ -2,37 +2,34 @@
   "name": "pac_man_board_game",
   "version": "0.1.1",
   "private": true,
-  "type": "module",
   "dependencies": {
-    "@emotion/react": "^11.11.3",
-    "@headlessui/react": "^1.7.18",
-    "@heroicons/react": "^2.1.1",
-    "jotai": "^2.6.1",
-    "jotai-devtools": "^0.7.1",
+    "@emotion/react": "^11.11.1",
+    "@headlessui/react": "^1.7.17",
+    "@heroicons/react": "^2.0.18",
+    "jotai": "^2.3.1",
+    "jotai-devtools": "^0.6.2",
     "oidc-client": "^1.11.5",
     "react": "^18.2.0",
     "react-dom": "^18.2.0",
-    "react-router-dom": "^6.21.1",
-    "web-vitals": "^3.5.1"
+    "react-router-dom": "^6.15.0",
+    "web-vitals": "^3.4.0"
   },
   "devDependencies": {
-    "@types/node": "^20.10.8",
-    "@types/react": "^18.2.47",
-    "@types/react-dom": "^18.2.18",
-    "@vitejs/plugin-react": "^4.2.1",
-    "@vitest/coverage-v8": "^1.1.3",
+    "@types/react": "^18.2.33",
+    "@types/react-dom": "^18.2.14",
+    "@vitejs/plugin-react": "^4.1.0",
+    "@vitest/coverage-c8": "^0.33.0",
     "autoprefixer": "^10.4.16",
     "cross-env": "^7.0.3",
-    "happy-dom": "^12.10.3",
-    "postcss": "^8.4.33",
-    "prettier": "^3.1.1",
-    "tailwindcss": "^3.4.1",
-    "typescript": "^5.3.3",
-    "vite": "^5.0.11",
-    "vite-plugin-node-polyfills": "^0.19.0",
-    "vite-plugin-svgr": "^4.2.0",
-    "vite-tsconfig-paths": "^4.2.3",
-    "vitest": "^1.1.3"
+    "happy-dom": "^12.9.1",
+    "postcss": "^8.4.31",
+    "tailwindcss": "^3.3.3",
+    "typescript": "^5.1.6",
+    "vite": "^4.4.9",
+    "vite-plugin-node-polyfills": "^0.15.0",
+    "vite-plugin-svgr": "^3.2.0",
+    "vite-tsconfig-paths": "^4.2.0",
+    "vitest": "^0.34.6"
   },
   "resolutions": {
     "css-what": "^5.0.1",
@@ -44,8 +41,7 @@
     "build": "vite build",
     "serve": "vite preview",
     "test": "cross-env CI=true vitest",
-    "coverage": "vitest run --coverage",
-    "format": "prettier --write \"src/**/*.{js,jsx,ts,tsx,json,css,md}\""
+    "coverage": "vitest run --coverage"
   },
   "browserslist": {
     "production": [

pac-man-board-game/ClientApp/src/App.tsx

@@ -1,21 +1,21 @@
-import React, { FC } from "react"
-import { Navigate, Route, Routes } from "react-router-dom"
-import Layout from "./components/layout"
-import AppRoutes from "./AppRoutes"
-import "./index.css"
-import { useAtomValue } from "jotai"
-import { thisPlayerAtom } from "./utils/state"
+import React, {FC} from "react";
+import {Navigate, Route, Routes} from "react-router-dom";
+import Layout from "./components/layout";
+import AppRoutes from "./AppRoutes";
+import "./index.css";
+import {useAtomValue} from "jotai";
+import {thisPlayerAtom} from "./utils/state";
 
 export const App: FC = () => (
   <Layout>
     <Routes>
       {AppRoutes.map((route, index) => {
-        const { element, secured = false, ...rest } = route
-        return <Route key={index} {...rest} element={<Secured secured={secured}>{element}</Secured>} />
+        const {element, secured = false, ...rest} = route;
+        return <Route key={index} {...rest} element={<Secured secured={secured}>{element}</Secured>}/>;
       })}
     </Routes>
   </Layout>
-)
+);
 
 /**
  * This component is used to redirect the user to the login page if they are not logged in and the page is secured.
@@ -23,12 +23,10 @@ export const App: FC = () => (
  * @param secured Whether or not the page is secured.
  * @constructor The Secured component.
  */
-const Secured: FC<
-  {
+const Secured: FC<{
   secured: boolean
-  } & ChildProps
-> = ({ children, secured }) => {
-  const player = useAtomValue(thisPlayerAtom)
+} & ChildProps> = ({children, secured}) => {
+  const player = useAtomValue(thisPlayerAtom);
 
   if (secured && player === undefined) {
     return <Navigate to={"/login"} replace/>

pac-man-board-game/ClientApp/src/AppRoutes.tsx

@@ -1,37 +1,37 @@
-import React from "react"
-import { Counter } from "./pages/counter"
-import GamePage from "./pages/game"
-import LobbyPage from "./pages/lobby"
-import LoginPage from "./pages/login"
-import HomePage from "./pages/home"
+import React from "react";
+import {Counter} from "./pages/counter";
+import GamePage from "./pages/game";
+import LobbyPage from "./pages/lobby";
+import LoginPage from "./pages/login";
+import HomePage from "./pages/home";
 
 const AppRoutes = [
   {
     index: true,
-    element: <HomePage />,
+    element: <HomePage/>
   },
   {
     path: "/counter",
-    element: <Counter />,
+    element: <Counter/>
   },
   {
     path: "/game/:id",
     element: <GamePage/>,
-    secured: true,
+    secured: true
   },
   {
     path: "/lobby",
     element: <LobbyPage/>,
-    secured: true,
+    secured: true
   },
   {
     path: "/login",
-    element: <LoginPage />,
+    element: <LoginPage/>
   },
   {
     path: "*",
-    element: <p>Page not found</p>,
-  },
-]
+    element: <p>Page not found</p>
+  }
+];
 
-export default AppRoutes
+export default AppRoutes;

pac-man-board-game/ClientApp/src/components/button.tsx

@@ -1,6 +1,7 @@
-import React, { FC } from "react"
+import React, {FC} from "react";
 
-export const Button: FC<ButtonProps> = ({
+export const Button: FC<ButtonProps> = (
+  {
     className,
     onClick,
     style,

pac-man-board-game/ClientApp/src/components/debugMenu.tsx

@@ -1,34 +1,36 @@
-import React, { FC } from "react"
-import useToggle from "../hooks/useToggle"
-import { BugAntIcon } from "@heroicons/react/20/solid"
-import { selectedMapAtom } from "../utils/state"
-import { useAtom } from "jotai"
+import React, {FC} from "react";
+import useToggle from "../hooks/useToggle";
+import {BugAntIcon} from "@heroicons/react/20/solid";
+import {selectedMapAtom} from "../utils/state";
+import {useAtom} from "jotai";
 
 const DebugMenu: FC = () => {
-  const [open, toggleOpen] = useToggle()
+
+  const [open, toggleOpen] = useToggle();
 
   if (import.meta.env.DEV) {
     return (
       <div>
         {open && <DebugOptions/>}
-        <button
-          className={"fixed bottom-2 right-2 bg-gray-800 text-white p-2 z-50 rounded-full"}
+        <button className={"fixed bottom-2 right-2 bg-gray-800 text-white p-2 z-50 rounded-full"}
                 title={"Debug menu"}
                 onClick={() => toggleOpen()}>
           <BugAntIcon className={"w-8 m-1"}/>
         </button>
       </div>
-    )
+
+    );
   }
 }
 
-export default DebugMenu
+export default DebugMenu;
 
 const DebugOptions: FC = () => {
-  const [map, setMap] = useAtom(selectedMapAtom)
+
+  const [map, setMap] = useAtom(selectedMapAtom);
 
   function clearSessionStorage(): void {
-    sessionStorage.clear()
+    sessionStorage.clear();
   }
 
   function restartGame(): void {

pac-man-board-game/ClientApp/src/components/dice.tsx

@@ -1,49 +1,56 @@
-import React, { FC } from "react"
-import { useAtom, useAtomValue } from "jotai"
-import { selectedDiceAtom, thisPlayerAtom } from "../utils/state"
-import { Button } from "./button"
+import React, {FC} from "react";
+import {useAtom, useAtomValue} from "jotai";
+import {selectedDiceAtom, thisPlayerAtom,} from "../utils/state";
+import {Button} from "./button";
 
-export const AllDice: FC<{ values?: number[] } & ComponentProps> = ({ className, values }) => {
-  const [selectedDice, setSelectedDice] = useAtom(selectedDiceAtom)
+export const AllDice: FC<{ values?: number[] } & ComponentProps> = (
+  {
+    className,
+    values,
+  }) => {
+
+  const [selectedDice, setSelectedDice] = useAtom(selectedDiceAtom);
 
   function handleClick(dice: SelectedDice): void {
-    setSelectedDice(dice)
+    setSelectedDice(dice);
   }
 
   return (
     <div className={"flex gap-5 justify-center"}>
-      {values?.map((value, index) => (
-        <Dice
-          key={index}
+      {values?.map((value, index) =>
+        <Dice key={index}
               className={`${selectedDice?.index === index ? "border-2 border-black" : ""} ${className}`}
               value={value}
-          onClick={value => handleClick({ index, value })}
-        />
-      ))}
+              onClick={(value) => handleClick({index, value})}/>)}
     </div>
-  )
-}
+  );
+};
 
 interface DiceProps extends ComponentProps {
-  value?: number
-  onClick?: (value: number) => void
+  value?: number,
+  onClick?: (value: number) => void,
 }
 
-export const Dice: FC<DiceProps> = ({ className, value, onClick }) => {
-  const thisPlayer = useAtomValue(thisPlayerAtom)
+export const Dice: FC<DiceProps> = (
+  {
+    className,
+    value,
+    onClick,
+  }) => {
+
+  const thisPlayer = useAtomValue(thisPlayerAtom);
 
   function handleClick() {
     if (onClick && value) {
-      onClick(value)
+      onClick(value);
     }
   }
 
   return (
-    <Button
-      className={`text-2xl bg-gray-400 px-4 m-1 ${className}`}
+    <Button className={`text-2xl bg-gray-400 px-4 m-1 ${className}`}
             disabled={!thisPlayer?.isTurn()}
             onClick={handleClick}>
       {value?.toString()}
     </Button>
-  )
-}
+  );
+};

pac-man-board-game/ClientApp/src/components/dropdown.tsx

@@ -1,17 +1,24 @@
-import React, { forwardRef, ReactEventHandler } from "react"
+import React, {forwardRef, ReactEventHandler} from "react";
 
 export interface DropdownProps extends ComponentProps {
-  options?: string[]
-  onSelect?: ReactEventHandler<HTMLSelectElement>
+  options?: string[],
+  onSelect?: ReactEventHandler<HTMLSelectElement>,
 }
 
-const Dropdown: FRComponent<DropdownProps, HTMLSelectElement> = forwardRef(({ className, options, onSelect }, ref) => (
-  <select
-    ref={ref}
-    className={"border-2 border-gray-300 rounded-md py-1 px-2 bg-white " + className}
+const Dropdown: FRComponent<DropdownProps, HTMLSelectElement> = forwardRef((
+  {
+    className,
+    options,
+    onSelect
+  }, ref) => (
+  <select ref={ref} className={"border-2 border-gray-300 rounded-md py-1 px-2 bg-white " + className}
           onSelect={onSelect}>
-    {options?.map((option, index) => <option key={index}>{option}</option>)}
-  </select>
+    {
+      options?.map((option, index) => (
+        <option key={index}>{option}</option>
       ))
+    }
+  </select>
+));
 
-export default Dropdown
+export default Dropdown;

pac-man-board-game/ClientApp/src/components/gameBoard.tsx

@@ -1,108 +1,117 @@
-import React, { FC, Fragment, useEffect, useState } from "react"
-import { Character } from "../game/character"
-import findPossiblePositions from "../game/possibleMovesAlgorithm"
-import { GameTile } from "./gameTile"
-import { TileType } from "../game/tileType"
-import { atom, useAtom, useAtomValue, useSetAtom } from "jotai"
-import { allCharactersAtom, currentPlayerAtom, playersAtom, selectedDiceAtom } from "../utils/state"
-import { Dialog, Transition } from "@headlessui/react"
+import React, {FC, Fragment, useEffect, useState} from "react";
+import {Character} from "../game/character";
+import findPossiblePositions from "../game/possibleMovesAlgorithm";
+import {GameTile} from "./gameTile";
+import {TileType} from "../game/tileType";
+import {atom, useAtom, useAtomValue, useSetAtom} from "jotai";
+import {allCharactersAtom, currentPlayerAtom, playersAtom, selectedDiceAtom} from "../utils/state";
+import {Dialog, Transition} from "@headlessui/react";
 
 interface BoardProps extends ComponentProps {
-  onMove?: Action<Position[]>
+  onMove?: Action<Position[]>,
   map: GameMap
 }
 
-const modalOpenAtom = atom(false)
+const modalOpenAtom = atom(false);
 
-const Board: FC<BoardProps> = ({ className, onMove, map }) => {
-  const currentPlayer = useAtomValue(currentPlayerAtom)
-  const characters = useAtomValue(allCharactersAtom)
-  const selectedDice = useAtomValue(selectedDiceAtom)
-  const [selectedCharacter, setSelectedCharacter] = useState<Character>()
-  const [possiblePositions, setPossiblePositions] = useState<Path[]>([])
-  const [hoveredPosition, setHoveredPosition] = useState<Path>()
-  const setModalOpen = useSetAtom(modalOpenAtom)
+const Board: FC<BoardProps> = (
+  {
+    className,
+    onMove,
+    map
+  }) => {
+
+  const currentPlayer = useAtomValue(currentPlayerAtom);
+  const characters = useAtomValue(allCharactersAtom);
+  const selectedDice = useAtomValue(selectedDiceAtom);
+  const [selectedCharacter, setSelectedCharacter] = useState<Character>();
+  const [possiblePositions, setPossiblePositions] = useState<Path[]>([]);
+  const [hoveredPosition, setHoveredPosition] = useState<Path>();
+  const setModalOpen = useSetAtom(modalOpenAtom);
 
   function handleSelectCharacter(character: Character): void {
     if (character.isPacMan() && currentPlayer?.pacMan.colour !== character.colour) {
-      return
+      return;
     }
-    setSelectedCharacter(character)
+    setSelectedCharacter(character);
   }
 
   function handleShowPath(path: Path): void {
-    setHoveredPosition(path)
+    setHoveredPosition(path);
   }
 
   function handleMoveCharacter(destination: Path): void {
     if (selectedCharacter) {
-      setHoveredPosition(undefined)
+      setHoveredPosition(undefined);
 
       if (selectedCharacter.isGhost()) {
-        tryMovePacManToSpawn(destination)
+        tryMovePacManToSpawn(destination);
       }
 
-      selectedCharacter.follow(destination)
+      selectedCharacter.follow(destination);
 
-      const positions = pickUpPellets(destination)
-      onMove?.(positions)
-      setSelectedCharacter(undefined)
+      const positions = pickUpPellets(destination);
+      onMove?.(positions);
+      setSelectedCharacter(undefined);
     }
   }
 
   function tryMovePacManToSpawn(destination: Path): void {
-    const takenChar = characters.find(c => c.isPacMan() && c.isAt(destination.end))
+    const takenChar = characters.find(c => c.isPacMan() && c.isAt(destination.end));
     if (takenChar) {
-      takenChar.moveToSpawn()
-      stealFromPlayer()
+      takenChar.moveToSpawn();
+      stealFromPlayer();
     }
   }
 
   function stealFromPlayer(): void {
-    setModalOpen(true)
+    setModalOpen(true);
   }
 
   function pickUpPellets(destination: Path): Position[] {
-    const positions: Position[] = []
+    const positions: Position[] = [];
     if (selectedCharacter?.isPacMan()) {
-      for (const tile of [...(destination.path ?? []), destination.end]) {
-        const currentTile = map[tile.y][tile.x]
+
+      for (const tile of [...destination.path ?? [], destination.end]) {
+        const currentTile = map[tile.y][tile.x];
 
         function updateTileAndPlayerBox(isPowerPellet = false): void {
           if (isPowerPellet) {
-            currentPlayer?.addPowerPellet()
+            currentPlayer?.addPowerPellet();
           } else {
-            currentPlayer?.addPellet()
+            currentPlayer?.addPellet();
           }
-          map[tile.y][tile.x] = TileType.empty
-          positions.push(tile)
+          map[tile.y][tile.x] = TileType.empty;
+          positions.push(tile);
         }
 
         if (currentTile === TileType.pellet) {
-          updateTileAndPlayerBox()
+          updateTileAndPlayerBox();
         } else if (currentTile === TileType.powerPellet) {
-          updateTileAndPlayerBox(true)
+          updateTileAndPlayerBox(true);
         }
       }
     }
-    return positions
+    return positions;
   }
 
   useEffect(() => {
     if (selectedCharacter && selectedDice) {
-      const possiblePaths = findPossiblePositions(map, selectedCharacter, selectedDice.value, characters)
-      setPossiblePositions(possiblePaths)
+      const possiblePaths = findPossiblePositions(map, selectedCharacter, selectedDice.value, characters);
+      setPossiblePositions(possiblePaths);
     } else {
-      setPossiblePositions([])
+      setPossiblePositions([]);
     }
-  }, [selectedCharacter, selectedDice])
+  }, [selectedCharacter, selectedDice]);
 
   return (
     <div className={`w-fit ${className}`}>
       <SelectPlayerModal/>
-      {map.map((row, rowIndex) => (
+      {
+        map.map((row, rowIndex) =>
           <div key={rowIndex} className={"flex"}>
-          {row.map((tile, colIndex) => (
+            {
+              row.map((tile, colIndex) =>
                 <GameTile
                   key={colIndex + rowIndex * colIndex}
                   type={tile}
@@ -113,26 +122,26 @@ const Board: FC<BoardProps> = ({ className, onMove, map }) => {
                   handleMoveCharacter={handleMoveCharacter}
                   handleSelectCharacter={handleSelectCharacter}
                   handleStartShowPath={handleShowPath}
-              handleStopShowPath={() => setHoveredPosition(undefined)}
-            />
-          ))}
-        </div>
-      ))}
-    </div>
+                  handleStopShowPath={() => setHoveredPosition(undefined)}/>
               )
             }
+          </div>)
+      }
+    </div>
+  );
+};
 
-export default Board
+export default Board;
 
 const SelectPlayerModal: FC = () => {
-  const [isOpen, setIsOpen] = useAtom(modalOpenAtom)
-  const currentPlayer = useAtomValue(currentPlayerAtom)
-  const allPlayers = useAtomValue(playersAtom).filter(p => p !== currentPlayer)
+  const [isOpen, setIsOpen] = useAtom(modalOpenAtom);
+  const currentPlayer = useAtomValue(currentPlayerAtom);
+  const allPlayers = useAtomValue(playersAtom).filter(p => p !== currentPlayer);
 
-  if (currentPlayer === undefined) return null
+  if (currentPlayer === undefined) return null;
 
   function close(): void {
-    setIsOpen(false)
+    setIsOpen(false);
   }
 
   return (
@@ -146,7 +155,8 @@ const SelectPlayerModal: FC = () => {
             enterTo="opacity-100"
             leave="ease-in duration-200"
             leaveFrom="opacity-100"
-            leaveTo="opacity-0">
+            leaveTo="opacity-0"
+          >
             <div className="fixed inset-0 bg-black bg-opacity-25"/>
           </Transition.Child>
 
@@ -159,8 +169,10 @@ const SelectPlayerModal: FC = () => {
                 enterTo="opacity-100 scale-100"
                 leave="ease-in duration-200"
                 leaveFrom="opacity-100 scale-100"
-                leaveTo="opacity-0 scale-95">
-                <Dialog.Panel className="w-full max-w-md transform overflow-hidden rounded-2xl bg-white p-6 text-left align-middle shadow-xl transition-all">
+                leaveTo="opacity-0 scale-95"
+              >
+                <Dialog.Panel
+                  className="w-full max-w-md transform overflow-hidden rounded-2xl bg-white p-6 text-left align-middle shadow-xl transition-all">
                   <Dialog.Title as="h3" className="text-lg font-medium leading-6 text-gray-900">
                     Steal from player
                   </Dialog.Title>
@@ -170,29 +182,29 @@ const SelectPlayerModal: FC = () => {
                     </Dialog.Description>
                   </div>
 
-                  {allPlayers.map(player => (
+                  {
+                    allPlayers.map(player =>
                       <div key={player.username} className={"border-b pb-1"}>
-                      <span className={"mx-2"}>
-                        {player.username} has {player.box.pellets} pellets
-                      </span>
-                      <button
-                        className={"text-blue-500 enabled:cursor-pointer disabled:text-gray-500"}
+                        <span className={"mx-2"}>{player.username} has {player.box.pellets} pellets</span>
+                        <button className={"text-blue-500 enabled:cursor-pointer disabled:text-gray-500"}
                                 style={{background: "none"}}
                                 disabled={player.box.pellets === 0}
                                 onClick={() => {
-                          currentPlayer?.stealFrom(player)
-                          close()
+                                  currentPlayer?.stealFrom(player);
+                                  close();
                                 }}>
                           Steal
                         </button>
                       </div>
-                  ))}
+                    )
+                  }
 
                   <div className="mt-4">
                     <button
                       type="button"
                       className="inline-flex justify-center rounded-md border border-transparent bg-blue-100 px-4 py-2 text-sm font-medium text-blue-900 hover:bg-blue-200 focus:outline-none focus-visible:ring-2 focus-visible:ring-blue-500 focus-visible:ring-offset-2"
-                      onClick={close}>
+                      onClick={close}
+                    >
                       Don't steal from anyone
                     </button>
                   </div>

pac-man-board-game/ClientApp/src/components/gameButton.tsx

@@ -1,36 +1,33 @@
-import React, { FC, MouseEventHandler } from "react"
-import { State } from "../game/player"
-import { currentPlayerAtom, playersAtom, rollDiceButtonAtom, thisPlayerAtom } from "../utils/state"
-import { useAtomValue } from "jotai"
-import { Button } from "./button"
-import rules from "../game/rules"
+import React, {FC, MouseEventHandler} from "react";
+import {State} from "../game/player";
+import {currentPlayerAtom, playersAtom, rollDiceButtonAtom, thisPlayerAtom} from "../utils/state";
+import {useAtomValue} from "jotai";
+import {Button} from "./button";
+import rules from "../game/rules";
 
 interface GameButtonProps extends ComponentProps {
-  onReadyClick?: MouseEventHandler
+  onReadyClick?: MouseEventHandler,
   onRollDiceClick?: MouseEventHandler
 }
 
-const GameButton: FC<GameButtonProps> = ({ onReadyClick, onRollDiceClick }) => {
-  const currentPlayer = useAtomValue(currentPlayerAtom)
-  const thisPlayer = useAtomValue(thisPlayerAtom)
-  const players = useAtomValue(playersAtom)
-  const activeRollDiceButton = useAtomValue(rollDiceButtonAtom)
+const GameButton: FC<GameButtonProps> = (
+  {
+    onReadyClick,
+    onRollDiceClick,
+  }) => {
 
-  if (
-    players.length >= rules.minPlayers &&
-    (currentPlayer === undefined || currentPlayer.state === State.waitingForPlayers)
-  ) {
-    return <Button onClick={onReadyClick}>Ready</Button>
-  }
-  if (!thisPlayer?.isTurn()) {
-    // TODO also show when waiting for other players
-    return <Button disabled>Please wait</Button>
-  }
-  return (
-    <Button onClick={onRollDiceClick} disabled={!activeRollDiceButton}>
-      Roll dice
-    </Button>
-  )
-}
+  const currentPlayer = useAtomValue(currentPlayerAtom);
+  const thisPlayer = useAtomValue(thisPlayerAtom);
+  const players = useAtomValue(playersAtom);
+  const activeRollDiceButton = useAtomValue(rollDiceButtonAtom);
 
-export default GameButton
+  if (players.length >= rules.minPlayers && (currentPlayer === undefined || currentPlayer.state === State.waitingForPlayers)) {
+    return <Button onClick={onReadyClick}>Ready</Button>;
+  }
+  if (!thisPlayer?.isTurn()) { // TODO also show when waiting for other players
+    return <Button disabled>Please wait</Button>;
+  }
+  return <Button onClick={onRollDiceClick} disabled={!activeRollDiceButton}>Roll dice</Button>;
+};
+
+export default GameButton;

pac-man-board-game/ClientApp/src/components/gameComponent.tsx

@@ -1,46 +1,39 @@
-import React, { FC, useEffect } from "react"
-import { AllDice } from "./dice"
-import { doAction, GameAction } from "../utils/actions"
-import GameBoard from "./gameBoard"
-import WebSocketService from "../websockets/WebSocketService"
-import Player from "../game/player"
-import PlayerStats from "../components/playerStats"
-import { useAtom, useAtomValue, useSetAtom } from "jotai"
-import { diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedDiceAtom } from "../utils/state"
-import GameButton from "./gameButton"
-import { Button } from "./button"
-import { useNavigate, useParams } from "react-router-dom"
-import { getData } from "../utils/api"
+import React, {FC, useEffect} from "react";
+import {AllDice} from "./dice";
+import {doAction, GameAction} from "../utils/actions";
+import GameBoard from "./gameBoard";
+import WebSocketService from "../websockets/WebSocketService";
+import Player from "../game/player";
+import PlayerStats from "../components/playerStats";
+import {useAtom, useAtomValue, useSetAtom} from "jotai";
+import {diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedDiceAtom} from "../utils/state";
+import GameButton from "./gameButton";
+import {Button} from "./button";
+import {useNavigate, useParams} from "react-router-dom";
+import {getData} from "../utils/api";
 
-const wsService = new WebSocketService(import.meta.env.VITE_API_WS)
+const wsService = new WebSocketService(import.meta.env.VITE_API_WS);
 
-/**
- * Represents the main game component.
- * @component
- * @param player - The current player.
- * @param map - The current game map.
- *
- * @returns The rendered game component.
- */
-export const GameComponent: FC<{ player: Player; map: GameMap }> = ({ player, map }) => {
-  const players = useAtomValue(playersAtom)
-  const dice = useAtomValue(diceAtom)
-  const [selectedDice, setSelectedDice] = useAtom(selectedDiceAtom)
-  const setActiveRollDiceButton = useSetAtom(rollDiceButtonAtom)
-  const ghosts = useAtomValue(ghostsAtom)
+export const GameComponent: FC<{ player: Player, map: GameMap }> = ({player, map}) => {
 
-  const navigate = useNavigate()
-  const { id } = useParams()
+  const players = useAtomValue(playersAtom);
+  const dice = useAtomValue(diceAtom);
+  const [selectedDice, setSelectedDice] = useAtom(selectedDiceAtom);
+  const setActiveRollDiceButton = useSetAtom(rollDiceButtonAtom);
+  const ghosts = useAtomValue(ghostsAtom);
+
+  const navigate = useNavigate();
+  const {id} = useParams();
 
   /**
    * Rolls the dice for the current player's turn.
    */
   function rollDice(): void {
-    if (!player.isTurn()) return
+    if (!player.isTurn()) return;
 
-    setSelectedDice(undefined)
-    wsService.send({ action: GameAction.rollDice })
-    setActiveRollDiceButton(false)
+    setSelectedDice(undefined);
+    wsService.send({action: GameAction.rollDice});
+    setActiveRollDiceButton(false);
   }
 
   /**
@@ -49,22 +42,22 @@ export const GameComponent: FC<{ player: Player; map: GameMap }> = ({ player, ma
    */
   function onCharacterMove(eatenPellets: Position[]): void {
     if (dice && selectedDice) {
-      dice.splice(selectedDice.index, 1)
+      dice.splice(selectedDice.index, 1);
     }
-    setSelectedDice(undefined)
+    setSelectedDice(undefined);
     const data: ActionMessage = {
       action: GameAction.moveCharacter,
       data: {
         dice: dice?.length ?? 0 > 0 ? dice : null,
         players: players,
         ghosts: ghosts,
-        eatenPellets: eatenPellets,
-      },
+        eatenPellets: eatenPellets
       }
-    wsService.send(data)
+    };
+    wsService.send(data);
 
     if (dice?.length === 0) {
-      endTurn()
+      endTurn();
     }
   }
 
@@ -77,15 +70,15 @@ export const GameComponent: FC<{ player: Player; map: GameMap }> = ({ player, ma
       data: {
         username: player.username,
         gameId: id,
-      } as JoinGameData,
-    })
+      } as JoinGameData
+    });
   }
 
   /**
    * Sends a ready action to the WebSocket service.
    */
   function sendReady(): void {
-    wsService.send({ action: GameAction.ready })
+    wsService.send({action: GameAction.ready});
   }
 
   /**
@@ -93,40 +86,44 @@ export const GameComponent: FC<{ player: Player; map: GameMap }> = ({ player, ma
    * to advance to the next player in the game.
    */
   function endTurn(): void {
-    wsService.send({ action: GameAction.nextPlayer })
+    wsService.send({action: GameAction.nextPlayer});
   }
 
   /**
    * Leaves the current game and navigates to the lobby.
    */
   function leaveGame(): void {
-    wsService.send({ action: GameAction.disconnect })
-    navigate("/lobby")
+    wsService.send({action: GameAction.disconnect});
+    navigate("/lobby");
   }
 
   useEffect(() => {
-    getData(`/game/exists/${id}`).then(res => {
-      if (!res.ok) {
-        return navigate("/lobby")
-      }
-      wsService.onReceive = doAction
-      wsService.open()
 
-      wsService.waitForOpen().then(() => joinGame())
+    getData(`/game/exists/${id}`)
+      .then(res => {
+        if (!res.ok) {
+          return navigate("/lobby");
+        }
+        wsService.onReceive = doAction;
+        wsService.open();
+
+        wsService.waitForOpen().then(() => joinGame());
       })
 
-    return () => wsService.close()
-  }, [])
+    return () => wsService.close();
+  }, []);
 
   return (
     <>
       <Button onClick={leaveGame}>Leave game</Button>
-      <div className={"flex justify-center"}>{players?.map(p => <PlayerStats key={p.username} player={p} />)}</div>
+      <div className={"flex justify-center"}>
+        {players?.map(p => <PlayerStats key={p.username} player={p}/>)}
+      </div>
       <div className={"flex-center"}>
         <GameButton onReadyClick={sendReady} onRollDiceClick={rollDice}/>
       </div>
       <AllDice values={dice}/>
       <GameBoard className={"mx-auto my-2"} onMove={onCharacterMove} map={map}/>
     </>
-  )
-}
+  );
+};

pac-man-board-game/ClientApp/src/components/gameTile.tsx

@@ -1,22 +1,23 @@
-import React, { FC, useEffect, useState } from "react"
-import { TileType } from "../game/tileType"
-import { Character, Dummy } from "../game/character"
-import { Direction } from "../game/direction"
-import { Colour } from "../game/colour"
+import React, {FC, useEffect, useState} from "react";
+import {TileType} from "../game/tileType";
+import {Character, Dummy} from "../game/character";
+import {Direction} from "../game/direction";
+import {Colour} from "../game/colour";
 
 interface TileWithCharacterProps extends ComponentProps {
-  possiblePath?: Path
-  character?: Character
-  type?: TileType
-  handleMoveCharacter?: Action<Path>
-  handleSelectCharacter?: Action<Character>
-  handleStartShowPath?: Action<Path>
-  handleStopShowPath?: VoidFunction
-  isSelected?: boolean
+  possiblePath?: Path,
+  character?: Character,
+  type?: TileType,
+  handleMoveCharacter?: Action<Path>,
+  handleSelectCharacter?: Action<Character>,
+  handleStartShowPath?: Action<Path>,
+  handleStopShowPath?: VoidFunction,
+  isSelected?: boolean,
   showPath?: boolean
 }
 
-export const GameTile: FC<TileWithCharacterProps> = ({
+export const GameTile: FC<TileWithCharacterProps> = (
+  {
     possiblePath,
     character,
     type,
@@ -25,77 +26,85 @@ export const GameTile: FC<TileWithCharacterProps> = ({
     handleStartShowPath,
     handleStopShowPath,
     isSelected = false,
-  showPath = false,
+    showPath = false
   }) => (
-  <Tile
-    className={`${possiblePath?.end && "border-4 border-white"}`}
+  <Tile className={`${possiblePath?.end ? "border-4 border-white" : ""}`}
         type={type}
         onClick={possiblePath ? () => handleMoveCharacter?.(possiblePath) : undefined}
         onMouseEnter={possiblePath ? () => handleStartShowPath?.(possiblePath) : undefined}
         onMouseLeave={handleStopShowPath}>
     <>
-      {character && (
+      {character &&
           <div className={"flex-center wh-full"}>
               <CharacterComponent
                   character={character}
                   onClick={handleSelectCharacter}
-            className={isSelected ? "animate-bounce" : ""}
-          />
+                  className={isSelected ? "animate-bounce" : ""}/>
           </div>
-      )}
+      }
       {showPath && <Circle/>}
       <AddDummy path={possiblePath}/>
     </>
   </Tile>
-)
+);
 
 const Circle: FC<{ colour?: Colour } & ComponentProps> = ({colour = Colour.white, className}) => (
   <div className={`flex-center w-full h-full ${className}`}>
-    <div className={`w-1/2 h-1/2 rounded-full`} style={{ backgroundColor: colour }} />
+    <div className={`w-1/2 h-1/2 rounded-full`}
+         style={{backgroundColor: colour}}/>
   </div>
-)
+);
 
 interface TileProps extends ChildProps {
-  type?: TileType
-  onClick?: VoidFunction
-  onMouseEnter?: VoidFunction
-  onMouseLeave?: VoidFunction
-  character?: Character
-  onCharacterClick?: Action<Character>
-  characterClass?: string
+  type?: TileType,
+  onClick?: VoidFunction,
+  onMouseEnter?: VoidFunction,
+  onMouseLeave?: VoidFunction,
+  character?: Character,
+  onCharacterClick?: Action<Character>,
+  characterClass?: string,
 }
 
-const Tile: FC<TileProps> = ({ type = TileType.empty, onClick, onMouseEnter, onMouseLeave, className, children }) => {
-  const [tileSize, setTileSize] = useState(2)
+const Tile: FC<TileProps> = (
+  {
+    type = TileType.empty,
+    onClick,
+    onMouseEnter,
+    onMouseLeave,
+    className,
+    children
+  }) => {
+
+  const [tileSize, setTileSize] = useState(2);
 
   function setColor(): string {
     switch (type) {
       case TileType.wall:
-        return "bg-blue-500"
+        return "bg-blue-500";
       case TileType.ghostSpawn:
-        return "bg-red-500"
+        return "bg-red-500";
       case TileType.pacmanSpawn:
-        return "bg-green-500" // TODO should be the colour of the player
+        return "bg-green-500"; // TODO should be the colour of the player
       default:
-        return "bg-black"
+        return "bg-black";
     }
   }
 
   useEffect(() => {
+
     function handleResize(): void {
-      const newSize = Math.floor(window.innerWidth / 16)
-      setTileSize(newSize)
+      const newSize = Math.floor(window.innerWidth / 16);
+      setTileSize(newSize);
     }
 
-    handleResize()
+    handleResize();
 
-    window.addEventListener("resize", handleResize)
-    return () => window.removeEventListener("resize", handleResize)
-  }, [])
+    window.addEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize);
+  }, []);
 
   return (
-    <div
-      className={`${setColor()} hover:border relative max-w-[75px] max-h-[75px] ${className}`}
+    <div className={`${setColor()} hover:border relative max-w-[75px] max-h-[75px] ${className}`}
          style={{width: `${tileSize}px`, height: `${tileSize}px`}}
          onClick={onClick}
          onMouseEnter={onMouseEnter}
@@ -104,48 +113,53 @@ const Tile: FC<TileProps> = ({ type = TileType.empty, onClick, onMouseEnter, onM
       {type === TileType.pellet && <Circle colour={Colour.yellow}/>}
       {type === TileType.powerPellet && <Circle colour={Colour.red}/>}
     </div>
-  )
-}
+  );
+};
 
 const AddDummy: FC<{ path?: Path } & ComponentProps> = ({path}) => (
   <>
-    {path && (
+    {path &&
         <div className={"flex-center wh-full"}>
             <CharacterComponent character={new Dummy(path)}/>
         </div>
-    )}
+    }
   </>
-)
+);
 
 interface CharacterComponentProps extends ComponentProps {
-  character?: Character
-  onClick?: Action<Character>
+  character?: Character,
+  onClick?: Action<Character>,
 }
 
-const CharacterComponent: FC<CharacterComponentProps> = ({ character, onClick, className }) => {
+const CharacterComponent: FC<CharacterComponentProps> = (
+  {
+    character,
+    onClick,
+    className
+  }) => {
+
   function getSide() {
     switch (character?.position?.direction) {
       case Direction.up:
-        return "right-1/4 top-0"
+        return "right-1/4 top-0";
       case Direction.down:
-        return "right-1/4 bottom-0"
+        return "right-1/4 bottom-0";
       case Direction.left:
-        return "left-0 top-1/4"
+        return "left-0 top-1/4";
       case Direction.right:
-        return "right-0 top-1/4"
+        return "right-0 top-1/4";
     }
   }
 
-  if (character === undefined) return null
+  if (character === undefined) return null;
 
   return (
-    <div
-      className={`rounded-full w-4/5 h-4/5 cursor-pointer hover:border border-black relative ${className}`}
+    <div className={`rounded-full w-4/5 h-4/5 cursor-pointer hover:border border-black relative ${className}`}
          style={{backgroundColor: `${character.colour}`}}
          onClick={() => onClick?.(character)}>
       <div>
         <div className={`absolute ${getSide()} w-1/2 h-1/2 rounded-full bg-black`}/>
       </div>
     </div>
-  )
-}
+  );
+};

pac-man-board-game/ClientApp/src/components/input.tsx

@@ -1,18 +1,23 @@
-import React, { forwardRef } from "react"
+import React, {forwardRef} from "react";
 
-const Input: FRComponent<InputProps, HTMLInputElement> = forwardRef(
-  ({ type = "text", className, id, placeholder, required = false, name, autoComplete = "off" }, ref) => (
-    <input
-      type={type}
+const Input: FRComponent<InputProps, HTMLInputElement> = forwardRef((
+  {
+    type = "text",
+    className,
+    id,
+    placeholder,
+    required = false,
+    name,
+    autoComplete = "off",
+  }, ref) => (
+  <input type={type}
          autoComplete={autoComplete}
          ref={ref}
          id={id}
          name={name}
          className={"border-2 border-gray-300 rounded-md p-1 " + className}
          placeholder={placeholder}
-      required={required}
-    />
-  ),
-)
+         required={required}/>
+));
 
-export default Input
+export default Input;

pac-man-board-game/ClientApp/src/components/layout.tsx

@@ -1,11 +1,13 @@
-import React, { FC } from "react"
-import NavMenu from "./navMenu"
+import React, {FC} from "react";
+import NavMenu from "./navMenu";
 
 const Layout: FC<ChildProps> = ({children}) => (
   <div>
     <NavMenu/>
-    <main>{children}</main>
+    <main>
+      {children}
+    </main>
   </div>
-)
+);
 
-export default Layout
+export default Layout;

pac-man-board-game/ClientApp/src/components/navMenu.tsx

@@ -1,89 +1,84 @@
-import React, { FC, useEffect } from "react"
-import { Link, useNavigate } from "react-router-dom"
-import { useAtom, useAtomValue } from "jotai"
-import { thisPlayerAtom } from "../utils/state"
-import { UserCircleIcon } from "@heroicons/react/24/outline"
-import useToggle from "../hooks/useToggle"
+import React, {FC, useEffect} from "react";
+import {Link, useNavigate} from "react-router-dom";
+import {useAtom, useAtomValue} from "jotai";
+import {thisPlayerAtom} from "../utils/state";
+import {UserCircleIcon} from "@heroicons/react/24/outline";
+import useToggle from "../hooks/useToggle";
 
 const NavMenu: FC = () => {
-  const player = useAtomValue(thisPlayerAtom)
+  const player = useAtomValue(thisPlayerAtom);
 
   return (
     <header className={"z-10"}>
       <nav className="mb-3 flex justify-between border-b-2">
-        <Link to="/">
-          <h2 className={"m-1"}>Pac-Man Board Game</h2>
-        </Link>
+        <Link to="/"><h2 className={"m-1"}>Pac-Man Board Game</h2></Link>
 
         <ul className="inline-flex gap-2 items-center mr-5 relative">
           <NavItem to="/">Home</NavItem>
-          {player === undefined ? (
-            <NavItem className={"mx-2"} to={"/login"}>
-              Login
-            </NavItem>
-          ) : (
+          {
+            player === undefined ?
+              <NavItem className={"mx-2"} to={"/login"}>Login</NavItem>
+              :
               <>
                 <NavItem to={"/lobby"}>Lobby</NavItem>
                 <ProfileDropdown className={"mx-2"}/>
               </>
-          )}
+          }
         </ul>
       </nav>
     </header>
-  )
-}
+  );
+};
 
-export default NavMenu
+export default NavMenu;
 
 const NavItem: FC<LinkProps> = ({to, children, className}) => (
   <li>
-    <Link className={`hover:underline ${className}`} to={to}>
-      {children}
-    </Link>
+    <Link className={`hover:underline ${className}`} to={to}>{children}</Link>
   </li>
-)
+);
 
 const ProfileDropdown: FC<ComponentProps> = ({className}) => {
-  const [player, setPlayer] = useAtom(thisPlayerAtom)
-  const [isOpened, toggleOpen] = useToggle()
-  const navigate = useNavigate()
+  const [player, setPlayer] = useAtom(thisPlayerAtom);
+  const [isOpened, toggleOpen] = useToggle();
+  const navigate = useNavigate();
 
   async function logout(): Promise<void> {
-    setPlayer(undefined)
-    navigate("/login")
+    setPlayer(undefined);
+    navigate("/login");
   }
 
   useEffect(() => {
+
     if (isOpened) {
       function closeIfOutsideButton(e: MouseEvent): void {
         if (isOpened && e.target instanceof HTMLElement) {
           if (e.target.closest("#profile-dropdown") === null) {
-            toggleOpen(false)
+            toggleOpen(false);
           }
         }
       }
 
-      document.addEventListener("click", closeIfOutsideButton)
-      return () => document.removeEventListener("click", closeIfOutsideButton)
+      document.addEventListener("click", closeIfOutsideButton);
+      return () => document.removeEventListener("click", closeIfOutsideButton);
     }
-  }, [isOpened])
+
+  }, [isOpened]);
 
   return (
     <>
-      <li
-        id={"profile-dropdown"}
+      <li id={"profile-dropdown"}
           className={`inline-flex-center cursor-pointer hover:bg-gray-100 h-full px-2 ${className}`}
           onClick={() => toggleOpen()}>
         <UserCircleIcon className={"w-7"}/>
         <span>{player?.username}</span>
       </li>
-      {isOpened && (
+      {
+        isOpened &&
           <div className={"absolute right-2 border rounded-b -bottom-9 px-5"}>
-          <button onClick={logout} className={"hover:underline py-1"}>
-            Logout
-          </button>
+              <button onClick={logout} className={"hover:underline py-1"}>Logout</button>
           </div>
-      )}
+      }
     </>
   )
 }

pac-man-board-game/ClientApp/src/components/playerStats.tsx

@@ -1,27 +1,29 @@
-import React, { FC } from "react"
-import Player, { State } from "../game/player"
-import { useAtomValue } from "jotai"
-import { currentPlayerNameAtom } from "../utils/state"
+import React, {FC} from "react";
+import Player, {State} from "../game/player";
+import {useAtomValue} from "jotai";
+import {currentPlayerNameAtom} from "../utils/state";
 
-const PlayerStats: FC<{ player: Player } & ComponentProps> = ({ player, className, id }) => {
-  const currentPlayerName = useAtomValue(currentPlayerNameAtom)
+const PlayerStats: FC<{ player: Player } & ComponentProps> = (
+  {
+    player,
+    className,
+    id
+  }) => {
+  const currentPlayerName = useAtomValue(currentPlayerNameAtom);
   return (
-    <div
-      key={player.colour}
-      className={`w-fit m-2 ${player.state === State.disconnected ? "text-gray-500" : ""} ${className}`}
-      id={id}>
+    <div key={player.colour}
+         className={`w-fit m-2 ${player.state === State.disconnected ? "text-gray-500" : ""} ${className}`} id={id}>
       <p className={player.username === currentPlayerName ? "underline" : ""}>Player: {player.username}</p>
       <p>Colour: {player.colour}</p>
-      {player.state === State.inGame || player.state === State.disconnected ? (
+      {player.state === State.inGame || player.state === State.disconnected ?
         <>
           <p>Pellets: {player.box.pellets}</p>
           <p>PowerPellets: {player.box.powerPellets}</p>
         </>
-      ) : (
-        <p>{player.state === State.waitingForPlayers ? "Waiting" : "Ready"}</p>
-      )}
+        :
+        <p>{player.state === State.waitingForPlayers ? "Waiting" : "Ready"}</p>}
     </div>
-  )
-}
+  );
+};
 
-export default PlayerStats
+export default PlayerStats;

pac-man-board-game/ClientApp/src/game/box.ts

@@ -1,31 +1,32 @@
 export default class Box implements BoxProps {
-  public readonly colour
-  public pellets
-  public powerPellets
+  public readonly colour;
+  public pellets;
+  public powerPellets;
 
   public constructor({colour, pellets = 0, powerPellets = 0}: BoxProps) {
-    this.colour = colour
-    this.pellets = pellets
-    this.powerPellets = powerPellets
+    this.colour = colour;
+    this.pellets = pellets;
+    this.powerPellets = powerPellets;
   }
 
   public addPellet(): void {
-    this.pellets++
+    this.pellets++;
   }
 
   public removePellet(): boolean {
-    if (this.pellets <= 0) return false
-    this.pellets--
-    return true
+    if (this.pellets <= 0) return false;
+    this.pellets--;
+    return true;
   }
 
   public addPowerPellet(): void {
-    this.powerPellets++
+    this.powerPellets++;
   }
 
   public removePowerPellet(): boolean {
-    if (this.powerPellets <= 0) return false
-    this.powerPellets--
-    return true
+    if (this.powerPellets <= 0) return false;
+    this.powerPellets--;
+    return true;
   }
+
 }

pac-man-board-game/ClientApp/src/game/character.ts

@@ -1,5 +1,5 @@
-import { Direction } from "./direction"
-import { Colour } from "./colour"
+import {Direction} from "./direction";
+import {Colour} from "./colour";
 
 export enum CharacterType {
   pacMan,
@@ -8,99 +8,81 @@ export enum CharacterType {
 }
 
 export class Character implements CharacterProps {
-  public readonly colour
-  public position
-  public isEatable
-  public readonly spawnPosition
-  public readonly type
+  public readonly colour;
+  public position;
+  public isEatable;
+  public readonly spawnPosition;
+  public readonly type;
 
-  public constructor({
+  public constructor(
+    {
       colour,
       position = null,
       type = CharacterType.dummy,
       isEatable = type === CharacterType.pacMan,
-    spawnPosition = null,
+      spawnPosition = null
     }: CharacterProps) {
-    this.colour = colour
-    this.isEatable = isEatable
-    this.spawnPosition = spawnPosition
+    this.colour = colour;
+    this.isEatable = isEatable;
+    this.spawnPosition = spawnPosition;
 
     if (position) {
-      this.position = position
+      this.position = position;
     } else {
-      this.position = spawnPosition
-        ? {
+      this.position = spawnPosition ? {
         end: spawnPosition!.at,
-            direction: spawnPosition!.direction,
-          }
-        : null
+        direction: spawnPosition!.direction
+      } : null;
     }
 
-    this.type = type
+    this.type = type;
   }
 
   public follow(path: Path): void {
     if (!this.position) {
-      this.position = path
+      this.position = path;
     } else {
-      this.position.end = path.end
-      this.position.direction = path.direction
-      this.position.path = undefined
+      this.position.end = path.end;
+      this.position.direction = path.direction;
+      this.position.path = undefined;
     }
   }
 
   public isPacMan(): boolean {
-    return this.type === CharacterType.pacMan
+    return this.type === CharacterType.pacMan;
   }
 
   public isGhost(): boolean {
-    return this.type === CharacterType.ghost
+    return this.type === CharacterType.ghost;
   }
 
   public moveToSpawn(): void {
-    if (!this.spawnPosition) return
-    this.follow({
-      end: this.spawnPosition.at,
-      direction: this.spawnPosition.direction,
-    })
+    if (!this.spawnPosition) return;
+    this.follow({end: this.spawnPosition.at, direction: this.spawnPosition.direction});
   }
 
   public isAt(position: Position): boolean {
-    return this.position !== null && this.position.end.x === position.x && this.position.end.y === position.y
+    return this.position !== null && this.position.end.x === position.x && this.position.end.y === position.y;
   }
 }
 
 export class PacMan extends Character implements CharacterProps {
-  public constructor({
-    colour,
-    position,
-    isEatable = true,
-    spawnPosition,
-    type = CharacterType.pacMan,
-  }: CharacterProps) {
-    super({
-      colour: colour,
-      position: position,
-      isEatable: isEatable,
-      spawnPosition: spawnPosition,
-      type: type,
-    })
+
+  public constructor({colour, position, isEatable = true, spawnPosition, type = CharacterType.pacMan}: CharacterProps) {
+    super({colour: colour, position: position, isEatable: isEatable, spawnPosition: spawnPosition, type: type});
   }
+
 }
 
 export class Ghost extends Character implements CharacterProps {
+
   public constructor({colour, position, isEatable, spawnPosition, type = CharacterType.ghost}: CharacterProps) {
-    super({
-      colour: colour,
-      position: position,
-      isEatable: isEatable,
-      spawnPosition: spawnPosition,
-      type: type,
-    })
+    super({colour: colour, position: position, isEatable: isEatable, spawnPosition: spawnPosition, type: type});
   }
 }
 
 export class Dummy extends Character implements CharacterProps {
+
   public constructor(position: Path) {
     super({
       colour: Colour.grey,
@@ -108,6 +90,7 @@ export class Dummy extends Character implements CharacterProps {
       isEatable: false,
       spawnPosition: {at: {x: 0, y: 0}, direction: Direction.up},
       type: CharacterType.dummy,
-    })
+    });
   }
+
 }

pac-man-board-game/ClientApp/src/game/colour.ts

@@ -8,4 +8,4 @@ export enum Colour {
   grey = "grey",
 }
 
-export const getColours = (): Colour[] => Object.values(Colour)
+export const getColours = (): Colour[] => Object.values(Colour);

pac-man-board-game/ClientApp/src/game/direction.ts

@@ -2,7 +2,8 @@ export enum Direction {
   left,
   up,
   right,
-  down,
+  down
 }
 
-export const getDirections = () => Object.values(Direction).filter(d => !isNaN(Number(d))) as Direction[]
+export const getDirections = () => Object.values(Direction)
+  .filter(d => !isNaN(Number(d))) as Direction[];

pac-man-board-game/ClientApp/src/game/map.ts

@@ -1,5 +1,5 @@
-import { CharacterType } from "./character"
-import { Direction } from "./direction"
+import {CharacterType} from "./character";
+import {Direction} from "./direction";
 
 /**
  * 0 = empty
@@ -25,28 +25,25 @@ export const customMap: GameMap = [
   [1, 2, 1, 0, 1, 2, 1, 0, 1, 2, 1, 0, 1, 2, 1],
   [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1],
   [1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1],
-]
+];
 
-export function getCharacterSpawns(map: GameMap): { type: CharacterType; position: DirectionalPosition }[] {
-  const result: { type: CharacterType; position: DirectionalPosition }[] = []
+export function getCharacterSpawns(map: GameMap): { type: CharacterType, position: DirectionalPosition }[] {
+
+  const result: { type: CharacterType, position: DirectionalPosition }[] = [];
   for (let row = 0; row < map.length; row++) {
     for (let col = 0; col < map.length; col++) {
       // TODO find direction
       if (map[row][col] === 4) {
-        result.push({
-          type: CharacterType.ghost,
-          position: { at: { x: col, y: row }, direction: Direction.up },
-        })
+        result.push({type: CharacterType.ghost, position: {at: {x: col, y: row}, direction: Direction.up}});
       } else if (map[row][col] === 5) {
         result.push({
-          type: CharacterType.pacMan,
-          position: { at: { x: col, y: row }, direction: Direction.up },
-        })
+          type: CharacterType.pacMan, position: {at: {x: col, y: row}, direction: Direction.up}
+        });
       }
     }
   }
 
-  return result
+  return result;
 }
 
 export function getPacManSpawns(map: GameMap): DirectionalPosition[] {

pac-man-board-game/ClientApp/src/game/player.ts

@@ -1,62 +1,54 @@
-import { Character, CharacterType } from "./character"
-import Box from "./box"
-import { getDefaultStore } from "jotai"
-import { currentPlayerNameAtom, playersAtom } from "../utils/state"
-import rules from "./rules"
+import {Character, CharacterType} from "./character";
+import Box from "./box";
+import {getDefaultStore} from "jotai";
+import {currentPlayerNameAtom, playersAtom} from "../utils/state";
+import rules from "./rules";
 
-/**
- * Represents the different states of a game.
- *
- * @enum {number}
- */
 export enum State {
   waitingForPlayers,
   ready,
   inGame,
-  disconnected,
+  disconnected
 }
 
 export default class Player implements PlayerProps {
-  private static store = getDefaultStore()
-  public readonly username
-  public readonly pacMan
-  public readonly colour
-  public readonly box
-  public state
+  private static store = getDefaultStore();
+  public readonly username;
+  public readonly pacMan;
+  public readonly colour;
+  public readonly box;
+  public state;
 
   constructor(props: PlayerProps) {
-    this.username = props.username
-    this.colour = props.colour
-    this.box = new Box(props.box ?? { colour: props.colour })
-    this.pacMan = new Character(
-      props.pacMan ?? {
+    this.username = props.username;
+    this.colour = props.colour;
+    this.box = new Box(props.box ?? {colour: props.colour});
+    this.pacMan = new Character(props.pacMan ?? {
       colour: props.colour,
-        type: CharacterType.pacMan,
-      },
-    )
-    this.state = props.state ?? State.waitingForPlayers
+      type: CharacterType.pacMan
+    });
+    this.state = props.state ?? State.waitingForPlayers;
   }
 
   public isTurn(): boolean {
-    return Player.store.get(currentPlayerNameAtom) === this.username
+    return Player.store.get(currentPlayerNameAtom) === this.username;
   }
 
   public addPellet(): void {
-    this.box.addPellet()
+    this.box.addPellet();
   }
 
   public addPowerPellet(): void {
-    this.box.addPowerPellet()
+    this.box.addPowerPellet();
   }
 
   public stealFrom(other: Player): void {
     for (let i = 0; i < rules.maxStealPellets; i++) {
-      const removed = other.box.removePellet()
-      if (removed) this.box.addPellet()
+      const removed = other.box.removePellet();
+      if (removed)
+        this.box.addPellet();
     }
-    Player.store.set(
-      playersAtom,
-      Player.store.get(playersAtom).map(player => player),
-    )
+    Player.store.set(playersAtom, Player.store.get(playersAtom).map(player => player));
   }
+
 }

pac-man-board-game/ClientApp/src/game/possibleMovesAlgorithm.ts

@@ -1,6 +1,6 @@
-import { TileType } from "./tileType"
-import { Character } from "./character"
-import { Direction, getDirections } from "./direction"
+import {TileType} from "./tileType";
+import {Character} from "./character";
+import {Direction, getDirections} from "./direction";
 
 /**
  * Finds all the possible positions for the character to move to
@@ -10,15 +10,10 @@ import { Direction, getDirections } from "./direction"
  * @param characters All the characters on the map
  * @returns An array of paths the character can move to
  */
-export default function findPossiblePositions(
-  board: GameMap,
-  character: Character,
-  steps: number,
-  characters: Character[],
-): Path[] {
-  if (!character.position || !character.spawnPosition) throw new Error("Character has no position or spawn position")
-  return findPossibleRecursive(board, character.position, steps, character, characters)
-}
+export default function findPossiblePositions(board: GameMap, character: Character, steps: number, characters: Character[]): Path[] {
+  if (!character.position || !character.spawnPosition) throw new Error("Character has no position or spawn position");
+  return findPossibleRecursive(board, character.position, steps, character, characters);
+};
 
 /**
  * Uses recursion to move through the map and find all the possible positions
@@ -29,40 +24,38 @@ export default function findPossiblePositions(
  * @param characters All the characters on the map
  * @returns {Path[]} An array of paths the character can move to
  */
-function findPossibleRecursive(
-  map: GameMap,
-  currentPath: Path,
-  steps: number,
-  character: Character,
-  characters: Character[],
-): Path[] {
-  const paths: Path[] = []
+function findPossibleRecursive(map: GameMap, currentPath: Path, steps: number, character: Character, characters: Character[]): Path[] {
+
+  const paths: Path[] = [];
   if (isOutsideBoard(currentPath, map.length)) {
     if (character.isPacMan()) {
-      return addTeleportationTiles(map, currentPath, steps, character, characters)
+      return addTeleportationTiles(map, currentPath, steps, character, characters);
     }
   } else if (!isWall(map, currentPath)) {
+
     if (!characterHitsAnotherCharacter(character, currentPath, characters)) {
       if (steps <= 0) {
         if (!(isSpawn(map, currentPath) && !isOwnSpawn(currentPath, character))) {
-          paths.push(currentPath)
+          paths.push(currentPath);
         }
-      } else {
-        tryAddToPath(currentPath)
 
-        steps--
+      } else {
+
+        tryAddToPath(currentPath);
+
+        steps--;
         for (const direction of getDirections()) {
-          paths.push(...tryMove(map, currentPath, direction, steps, character, characters))
+          paths.push(...tryMove(map, currentPath, direction, steps, character, characters));
         }
       }
     } else {
-      const pacMan = ghostHitsPacMan(character, currentPath, characters)
+      const pacMan = ghostHitsPacMan(character, currentPath, characters);
       if (pacMan instanceof Character && !isCharactersSpawn(currentPath, pacMan)) {
-        paths.push(currentPath)
+        paths.push(currentPath);
       }
     }
   }
-  return paths
+  return paths;
 }
 
 /**
@@ -72,7 +65,7 @@ function findPossibleRecursive(
  * @returns {boolean} True if the character is on its spawn, otherwise false
  */
 function isCharactersSpawn(currentPath: Path, character: Character): boolean {
-  return character.spawnPosition?.at.x === currentPath.end.x && character.spawnPosition.at.y === currentPath.end.y
+  return character.spawnPosition?.at.x === currentPath.end.x && character.spawnPosition.at.y === currentPath.end.y;
 }
 
 /**
@@ -82,12 +75,8 @@ function isCharactersSpawn(currentPath: Path, character: Character): boolean {
  * @param characters All the characters on the board
  * @returns {boolean} True if the character is a ghost and hits Pac-Man, otherwise false
  */
-function ghostHitsPacMan(
-  character: Character,
-  currentPath: Path,
-  characters: Character[],
-): Character | undefined | false {
-  return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.end))
+function ghostHitsPacMan(character: Character, currentPath: Path, characters: Character[]): Character | undefined | false {
+  return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.end));
 }
 
 /**
@@ -98,7 +87,7 @@ function ghostHitsPacMan(
  * @returns {boolean} True if the character hits another character, otherwise false
  */
 function characterHitsAnotherCharacter(character: Character, currentPath: Path, characters: Character[]): boolean {
-  return characters.find(c => c !== character && c.isAt(currentPath.end)) !== undefined
+  return characters.find(c => c !== character && c.isAt(currentPath.end)) !== undefined;
 }
 
 /**
@@ -107,9 +96,9 @@ function characterHitsAnotherCharacter(character: Character, currentPath: Path,
  */
 function tryAddToPath(currentPos: Path): void {
   if (!currentPos.path) {
-    currentPos.path = []
+    currentPos.path = [];
   } else if (!currentPos.path.includes(currentPos.end)) {
-    currentPos.path = [...currentPos.path, currentPos.end]
+    currentPos.path = [...currentPos.path, currentPos.end];
   }
 }
 
@@ -124,53 +113,39 @@ function tryAddToPath(currentPos: Path): void {
  * @param characters All the characters on the board
  * @returns An array of paths the character can move to
  */
-function tryMove(
-  board: GameMap,
-  path: Path,
-  direction: Direction,
-  steps: number,
-  character: Character,
-  characters: Character[],
-): Path[] {
+function tryMove(board: GameMap, path: Path, direction: Direction, steps: number, character: Character, characters: Character[]): Path[] {
+
   function getNewPosition(): Position {
     switch (direction) {
       case Direction.left:
         return {
           x: path.end.x - 1,
-          y: path.end.y,
-        }
+          y: path.end.y
+        };
       case Direction.up:
         return {
           x: path.end.x,
-          y: path.end.y - 1,
-        }
+          y: path.end.y - 1
+        };
       case Direction.right:
         return {
           x: path.end.x + 1,
-          y: path.end.y,
-        }
+          y: path.end.y
+        };
       case Direction.down:
         return {
           x: path.end.x,
-          y: path.end.y + 1,
-        }
+          y: path.end.y + 1
+        };
     }
   }
 
   if (path.direction !== (direction + 2) % 4) {
-    return findPossibleRecursive(
-      board,
-      {
-        end: getNewPosition(),
-        direction: direction,
-        path: path.path,
-      },
-      steps,
-      character,
-      characters,
-    )
+    return findPossibleRecursive(board, {
+      end: getNewPosition(), direction: direction, path: path.path
+    }, steps, character, characters);
   }
-  return []
+  return [];
 }
 
 /**
@@ -182,26 +157,22 @@ function tryMove(
  * @param characters All the characters on the map
  * @returns {Path[]} An array of paths the character can move to
  */
-function addTeleportationTiles(
-  board: GameMap,
-  currentPath: Path,
-  steps: number,
-  character: Character,
-  characters: Character[],
-): Path[] {
-  const possiblePositions = findTeleportationTiles(board)
-  const paths: Path[] = []
+function addTeleportationTiles(board: GameMap, currentPath: Path, steps: number, character: Character, characters: Character[]): Path[] {
+  const possiblePositions = findTeleportationTiles(board);
+  const paths: Path[] = [];
   for (const pos of possiblePositions) {
+
     function inInterval(coordinate: "x" | "y"): boolean {
       return pos.end[coordinate] !== interval(0, board.length - 1, currentPath.end[coordinate])
     }
 
     if (inInterval("x") || inInterval("y")) {
-      pos.path = currentPath.path
-      paths.push(...findPossibleRecursive(board, pos, steps, character, characters))
+
+      pos.path = currentPath.path;
+      paths.push(...findPossibleRecursive(board, pos, steps, character, characters));
     }
   }
-  return paths
+  return paths;
 }
 
 /**
@@ -212,7 +183,7 @@ function addTeleportationTiles(
  * @returns {number} The value if it's between the lower and upper bounds, otherwise it returns the lower or upper bound
  */
 function interval(lower: number, upper: number, value: number): number {
-  return Math.max(Math.min(value, upper), lower)
+  return Math.max(Math.min(value, upper), lower);
 }
 
 /**
@@ -221,17 +192,18 @@ function interval(lower: number, upper: number, value: number): number {
  * @returns An array of paths containing the teleportation tiles
  */
 function findTeleportationTiles(map: GameMap): Path[] {
-  const possiblePositions: Path[] = []
-  const edge = [0, map.length - 1]
+  const possiblePositions: Path[] = [];
+  const edge = [0, map.length - 1];
 
   for (const e of edge) {
     for (let i = 0; i < map[e].length; i++) {
-      pushPath(map, possiblePositions, i, e)
-      pushPath(map, possiblePositions, e, i)
+
+      pushPath(map, possiblePositions, i, e);
+      pushPath(map, possiblePositions, e, i);
     }
   }
 
-  return possiblePositions
+  return possiblePositions;
 }
 
 /**
@@ -243,10 +215,7 @@ function findTeleportationTiles(map: GameMap): Path[] {
  */
 function pushPath(board: GameMap, possiblePositions: Path[], x: number, y: number): void {
   if (board[y] && board[y][x] !== TileType.wall) {
-    possiblePositions.push({
-      end: { x: x, y: y },
-      direction: findDirection(x, y, board.length),
-    })
+    possiblePositions.push({end: {x: x, y: y}, direction: findDirection(x, y, board.length)});
   }
 }
 
@@ -257,17 +226,17 @@ function pushPath(board: GameMap, possiblePositions: Path[], x: number, y: numbe
  * @param boardSize The length of the board
  */
 function findDirection(x: number, y: number, boardSize: number): Direction {
-  let direction: Direction
+  let direction: Direction;
   if (x === 0) {
-    direction = Direction.right
+    direction = Direction.right;
   } else if (y === 0) {
-    direction = Direction.down
+    direction = Direction.down;
   } else if (x === boardSize - 1) {
-    direction = Direction.left
+    direction = Direction.left;
   } else {
-    direction = Direction.up
+    direction = Direction.up;
   }
-  return direction
+  return direction;
 }
 
 /**
@@ -276,8 +245,8 @@ function findDirection(x: number, y: number, boardSize: number): Direction {
  * @param boardSize The size of the board
  */
 function isOutsideBoard(currentPos: Path, boardSize: number): boolean {
-  const pos = currentPos.end
-  return pos.x < 0 || pos.x >= boardSize || pos.y < 0 || pos.y >= boardSize
+  const pos = currentPos.end;
+  return pos.x < 0 || pos.x >= boardSize || pos.y < 0 || pos.y >= boardSize;
 }
 
 /**
@@ -286,8 +255,8 @@ function isOutsideBoard(currentPos: Path, boardSize: number): boolean {
  * @param currentPos The current position of the character
  */
 function isWall(board: GameMap, currentPos: Path): boolean {
-  const pos = currentPos.end
-  return board[pos.y][pos.x] === TileType.wall // Shouldn't work, but it does
+  const pos = currentPos.end;
+  return board[pos.y][pos.x] === TileType.wall; // Shouldn't work, but it does
 }
 
 /**
@@ -296,8 +265,8 @@ function isWall(board: GameMap, currentPos: Path): boolean {
  * @param currentPos The current position of the character
  */
 function isSpawn(board: GameMap, currentPos: Path) {
-  const pos = currentPos.end
-  return board[pos.y][pos.x] === TileType.pacmanSpawn || board[pos.y][pos.x] === TileType.ghostSpawn
+  const pos = currentPos.end;
+  return board[pos.y][pos.x] === TileType.pacmanSpawn || board[pos.y][pos.x] === TileType.ghostSpawn;
 }
 
 /**
@@ -306,7 +275,8 @@ function isSpawn(board: GameMap, currentPos: Path) {
  * @param character The current character
  */
 function isOwnSpawn(currentPos: Path, character: Character): boolean {
-  const pos = currentPos.end
-  const charPos = character.spawnPosition!.at
-  return charPos.x === pos.x && charPos.y === pos.y
+  const pos = currentPos.end;
+  const charPos = character.spawnPosition!.at;
+  return charPos.x === pos.x && charPos.y === pos.y;
 }
+

pac-man-board-game/ClientApp/src/game/rules.ts

@@ -4,4 +4,4 @@ const rules = {
   maxStealPellets: 2,
 }
 
-export default rules
+export default rules;

pac-man-board-game/ClientApp/src/hooks/useToggle.ts

@@ -1,4 +1,4 @@
-import { useState } from "react"
+import {useState} from "react";
 
 /**
  * A hook that returns a boolean value and a function to toggle it. The function can optionally be passed a boolean
@@ -6,7 +6,7 @@ import { useState } from "react"
  * @returns A tuple containing the boolean value and a function to toggle it.
  */
 export default function useToggle(defaultValue = false): [boolean, (value?: boolean) => void] {
-  const [value, setValue] = useState(defaultValue)
-  const toggleValue = (newValue?: boolean) => (newValue ? setValue(newValue) : setValue(!value))
-  return [value, toggleValue]
+  const [value, setValue] = useState(defaultValue);
+  const toggleValue = (newValue?: boolean) => newValue ? setValue(newValue) : setValue(!value);
+  return [value, toggleValue];
 }

pac-man-board-game/ClientApp/src/index.css

@@ -31,9 +31,7 @@ br {
     @apply my-2;
 }
 
-.button-default,
-button[type="submit"],
-input[type="submit"] {
+.button-default, button[type=submit], input[type=submit] {
     @apply bg-blue-500 hover:bg-blue-600 text-white font-bold py-2 px-4 rounded;
     @apply disabled:bg-gray-500;
 }

pac-man-board-game/ClientApp/src/index.tsx

@@ -1,26 +1,25 @@
-import React from "react"
-import { createRoot } from "react-dom/client"
-import { BrowserRouter } from "react-router-dom"
-import { App } from "./App"
+import React from 'react';
+import {createRoot} from 'react-dom/client';
+import {BrowserRouter} from 'react-router-dom';
+import {App} from './App';
 // @ts-ignore
-import reportWebVitals from "./reportWebVitals"
-import { DevTools } from "jotai-devtools"
-import DebugMenu from "./components/debugMenu"
+import reportWebVitals from './reportWebVitals';
+import {DevTools} from "jotai-devtools";
+import DebugMenu from "./components/debugMenu";
 
-const baseUrl = document.getElementsByTagName("base")[0].getAttribute("href")
-const rootElement = document.getElementById("root")
-if (rootElement === null) throw new Error("Root element is null")
-const root = createRoot(rootElement)
+const baseUrl = document.getElementsByTagName('base')[0].getAttribute('href');
+const rootElement = document.getElementById('root');
+if (rootElement === null) throw new Error("Root element is null");
+const root = createRoot(rootElement);
 
 root.render(
   <BrowserRouter basename={baseUrl ?? undefined}>
     <DevTools/>
     <DebugMenu/>
     <App/>
-  </BrowserRouter>,
-)
+  </BrowserRouter>);
 
 // If you want to start measuring performance in your app, pass a function
 // to log results (for example: reportWebVitals(console.log))
 // or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
-reportWebVitals()
+reportWebVitals();

pac-man-board-game/ClientApp/src/pages/counter.tsx

@@ -1,27 +1,29 @@
-import React, { FC } from "react"
-import WebSocketService from "../websockets/WebSocketService"
+import React, {FC} from "react";
+import WebSocketService from "../websockets/WebSocketService";
 
-const ws = new WebSocketService("wss://localhost:3000/api/ws")
+const ws = new WebSocketService("wss://localhost:3000/api/ws");
 
 export const Counter: FC = () => {
-  const [currentCount, setCurrentCount] = React.useState(0)
 
-  function incrementCounterAndSend() {
+  const [currentCount, setCurrentCount] = React.useState(0);
+
+  async function incrementCounterAndSend() {
     if (ws.isOpen()) {
-      ws.send((currentCount + 1).toString())
+      await ws.send((currentCount + 1).toString());
     }
   }
 
   function receiveMessage(data: MessageEvent<string>) {
-    const count = parseInt(data.data)
-    if (!isNaN(count)) setCurrentCount(count)
+    const count = parseInt(data.data);
+    if (!isNaN(count))
+      setCurrentCount(count);
   }
 
   React.useEffect(() => {
-    ws.onReceive = receiveMessage
-    ws.open()
-    return () => ws.close()
-  }, [])
+    ws.onReceive = receiveMessage;
+    ws.open();
+    return () => ws.close();
+  }, []);
 
   return (
     <div>
@@ -29,13 +31,9 @@ export const Counter: FC = () => {
 
       <p>This is a simple example of a React component.</p>
 
-      <p aria-live="polite">
-        Current count: <strong>{currentCount}</strong>
-      </p>
+      <p aria-live="polite">Current count: <strong>{currentCount}</strong></p>
 
-      <button className="btn btn-primary" onClick={incrementCounterAndSend}>
-        Increment
-      </button>
+      <button className="btn btn-primary" onClick={incrementCounterAndSend}>Increment</button>
     </div>
-  )
-}
+  );
+};

pac-man-board-game/ClientApp/src/pages/game.tsx

@@ -1,16 +1,17 @@
-import React, { FC } from "react"
-import { GameComponent } from "../components/gameComponent"
-import { useAtomValue } from "jotai"
-import { selectedMapAtom, thisPlayerAtom } from "../utils/state"
+import React, {FC} from "react";
+import {GameComponent} from "../components/gameComponent";
+import {useAtomValue} from "jotai";
+import {selectedMapAtom, thisPlayerAtom} from "../utils/state";
 
 const GamePage: FC = () => {
-  const player = useAtomValue(thisPlayerAtom)
-  const map = useAtomValue(selectedMapAtom)
+  const player = useAtomValue(thisPlayerAtom);
+  const map = useAtomValue(selectedMapAtom);
 
   if (player && map) {
-    return <GameComponent player={player} map={map} />
-  }
-  return null
+    return <GameComponent player={player} map={map}/>;
+  } else {
+    return null;
   }
+};
 
-export default GamePage
+export default GamePage;

pac-man-board-game/ClientApp/src/pages/home.tsx

@@ -1,35 +1,27 @@
-import React, { FC } from "react"
-import { Link } from "react-router-dom"
-import { useAtomValue } from "jotai"
-import { thisPlayerAtom } from "../utils/state"
+import React, {FC} from "react";
+import {Link} from "react-router-dom";
+import {useAtomValue} from "jotai";
+import {thisPlayerAtom} from "../utils/state";
 
 const HomePage: FC = () => {
-  const player = useAtomValue(thisPlayerAtom)
+  const player = useAtomValue(thisPlayerAtom);
 
   return (
     <div className={"container max-w-[800px] mx-auto px-2"}>
       <h1 className={"w-fit mx-auto"}>Hello {player?.username ?? "Player"}. Do you want to play a game?</h1>
       <p className={"text-center mt-5"}>
-        {!player ? (
-          <>
-            Start by{" "}
-            <Link to={"/login"} className={"text-blue-600"}>
-              logging in
-            </Link>
-            .
+        {!player ?
+          <>Start by {" "}
+            <Link to={"/login"} className={"text-blue-600"}>logging in</Link>.
           </>
-        ) : (
-          <>
-            Go to the{" "}
-            <Link to={"/lobby"} className={"text-blue-600"}>
-              lobby
-            </Link>{" "}
-            to select a game.
+          :
+          <>Go to the {" "}
+            <Link to={"/lobby"} className={"text-blue-600"}>lobby</Link> to select a game.
           </>
-        )}
+        }
       </p>
     </div>
-  )
-}
+  );
+};
 
-export default HomePage
+export default HomePage;

pac-man-board-game/ClientApp/src/pages/lobby.tsx

@@ -1,37 +1,37 @@
-import React, { FC, Suspense } from "react"
-import { atom, useAtomValue } from "jotai"
-import { Button } from "../components/button"
-import { selectedMapAtom, thisPlayerAtom } from "../utils/state"
-import { getData, postData } from "../utils/api"
-import { getPacManSpawns } from "../game/map"
-import { useNavigate } from "react-router-dom"
+import React, {FC, Suspense} from "react";
+import {atom, useAtomValue} from "jotai";
+import {Button} from "../components/button";
+import {selectedMapAtom, thisPlayerAtom} from "../utils/state";
+import {getData, postData} from "../utils/api";
+import {getPacManSpawns} from "../game/map";
+import {useNavigate} from "react-router-dom";
 
 const fetchAtom = atom(async () => {
-  const response = await getData("/game/all")
-  return (await response.json()) as Game[]
-})
+  const response = await getData("/game/all");
+  return await response.json() as Game[];
+});
 
 const LobbyPage: FC = () => {
-  const thisPlayer = useAtomValue(thisPlayerAtom)
-  const navigate = useNavigate()
-  const map = useAtomValue(selectedMapAtom)
+
+  const thisPlayer = useAtomValue(thisPlayerAtom);
+  const navigate = useNavigate();
+  const map = useAtomValue(selectedMapAtom);
 
   async function createGame(): Promise<void> {
+
     const response = await postData("/game/create", {
-      body: {
-        player: thisPlayer,
-        spawns: getPacManSpawns(map),
-      } as CreateGameData,
-    })
+      body: {player: thisPlayer, spawns: getPacManSpawns(map)} as CreateGameData
+    });
 
     if (response.ok) {
-      const data = await response.json()
+      const data = await response.json();
       navigate("/game/" + data.id)
     } else {
-      const data = await response.text()
-      console.error("Error: ", data)
+      const data = await response.text();
+      console.error("Error: ", data);
       // TODO display error
     }
+
   }
 
   return (
@@ -41,25 +41,26 @@ const LobbyPage: FC = () => {
         <GameTable className={"mx-auto"}/>
       </Suspense>
     </>
-  )
+  );
 }
 
-export default LobbyPage
+export default LobbyPage;
 
 const GameTable: FC<ComponentProps> = ({className}) => {
-  const data = useAtomValue(fetchAtom)
-  const thisPlayer = useAtomValue(thisPlayerAtom)
-  const navigate = useNavigate()
+
+  const data = useAtomValue(fetchAtom);
+  const thisPlayer = useAtomValue(thisPlayerAtom);
+  const navigate = useNavigate();
 
   async function joinGame(gameId: string): Promise<void> {
-    if (thisPlayer === undefined) throw new Error("Player is undefined")
+    if (thisPlayer === undefined) throw new Error("Player is undefined");
 
-    const result = await postData("/game/join/" + gameId, { body: thisPlayer })
+    const result = await postData("/game/join/" + gameId, {body: thisPlayer});
 
     if (result.ok) {
-      navigate("/game/" + gameId)
+      navigate("/game/" + gameId);
     } else {
-      console.error("Failed to join game " + gameId, await result.text())
+      console.error("Failed to join game " + gameId, await result.text());
       // TODO show error message
     }
   }
@@ -75,7 +76,7 @@ const GameTable: FC<ComponentProps> = ({ className }) => {
       </tr>
       </thead>
       <tbody>
-        {data?.map(game => (
+      {data?.map(game =>
         <tr key={game.id} className={"even:bg-gray-200"}>
           <td className={"p-2"}>{game.id}</td>
           <td className={"text-center"}>{game.count}</td>
@@ -86,15 +87,14 @@ const GameTable: FC<ComponentProps> = ({ className }) => {
             </Button>
           </td>
         </tr>
-        ))}
-        {data?.length === 0 && (
-          <tr>
-            <td colSpan={4} className={"text-center"}>
-              No games found
-            </td>
-          </tr>
       )}
+      {
+        data?.length === 0 &&
+          <tr>
+              <td colSpan={4} className={"text-center"}>No games found</td>
+          </tr>
+      }
       </tbody>
     </table>
-  )
+  );
 }

pac-man-board-game/ClientApp/src/pages/login.tsx

@@ -1,22 +1,23 @@
-import React, { FC, FormEvent, useState } from "react"
-import { Button } from "../components/button"
-import Input from "../components/input"
-import { useSetAtom } from "jotai"
-import { thisPlayerAtom } from "../utils/state"
-import Player from "../game/player"
-import { useNavigate } from "react-router-dom"
-import { postData } from "../utils/api"
+import React, {FC, FormEvent, useState} from "react";
+import {Button} from "../components/button";
+import Input from "../components/input";
+import {useSetAtom} from "jotai";
+import {thisPlayerAtom} from "../utils/state";
+import Player from "../game/player";
+import {useNavigate} from "react-router-dom";
+import {postData} from "../utils/api";
 
 const LoginPage: FC = () => {
-  const setThisPlayer = useSetAtom(thisPlayerAtom)
-  const navigate = useNavigate()
-  const [error, setError] = useState<string | undefined>()
+
+  const setThisPlayer = useSetAtom(thisPlayerAtom);
+  const navigate = useNavigate();
+  const [error, setError] = useState<string | undefined>();
 
   async function handleLogin(e: FormEvent<HTMLFormElement>): Promise<void> {
-    e.preventDefault()
-    const fields = e.currentTarget.querySelectorAll("input")
+    e.preventDefault();
+    const fields = e.currentTarget.querySelectorAll("input");
 
-    let user: User = { username: "", password: "" }
+    let user: User = {username: "", password: ""};
     for (const field of fields) {
       user = {
         ...user,
@@ -25,22 +26,23 @@ const LoginPage: FC = () => {
     }
 
     const response = await postData("/player/login", {
-      body: { username: user.username, password: user.password } as User,
+      body: {username: user.username, password: user.password} as User
     })
 
+
     if (response.ok) {
-      const data = (await response.json()) as PlayerProps
-      setThisPlayer(new Player(data))
-      navigate("/lobby")
+      const data = await response.json() as PlayerProps;
+      setThisPlayer(new Player(data));
+      navigate("/lobby");
     } else {
-      const data = await response.text()
-      console.error(data)
-      setError(data)
-    }
+      const data = await response.text();
+      console.error(data);
+      setError(data);
     }
 
-  const username = "username",
-    password = "password"
+  }
+
+  const username = "username", password = "password";
 
   return (
     <form onSubmit={handleLogin} className={"container w-fit mx-auto flex flex-col gap-2"}>
@@ -49,17 +51,11 @@ const LoginPage: FC = () => {
       <label htmlFor={username}>Username:</label>
       <Input id={username} name={username} placeholder={"Username"} autoComplete={"username"} required/>
       <label htmlFor={password}>Password:</label>
-      <Input
-        id={password}
-        name={password}
-        type={"password"}
-        placeholder={"Password"}
-        autoComplete={"current-password"}
-        required
-      />
+      <Input id={password} name={password} type={"password"} placeholder={"Password"}
+             autoComplete={"current-password"} required/>
       <Button type={"submit"}>Login</Button>
     </form>
-  )
+  );
 }
 
-export default LoginPage
+export default LoginPage;

pac-man-board-game/ClientApp/src/reportWebVitals.js

@@ -1,13 +1,13 @@
-const reportWebVitals = onPerfEntry => {
+const reportWebVitals = (onPerfEntry) => {
   if (onPerfEntry && onPerfEntry instanceof Function) {
-    import("web-vitals").then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
-      getCLS(onPerfEntry)
-      getFID(onPerfEntry)
-      getFCP(onPerfEntry)
-      getLCP(onPerfEntry)
-      getTTFB(onPerfEntry)
-    })
-  }
+    import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
+      getCLS(onPerfEntry);
+      getFID(onPerfEntry);
+      getFCP(onPerfEntry);
+      getLCP(onPerfEntry);
+      getTTFB(onPerfEntry);
+    });
   }
+};
 
-export default reportWebVitals
+export default reportWebVitals;

pac-man-board-game/ClientApp/src/types/props.d.ts

@@ -1,27 +1,25 @@
-type FRComponent<T = ComponentProps, HTML extends HTMLElement = HTMLElement> = React.ForwardRefExoticComponent<
-  React.PropsWithoutRef<T> & React.RefAttributes<HTML>
->
+type FRComponent<T = ComponentProps, HTML extends HTMLElement = HTMLElement> = React.ForwardRefExoticComponent<React.PropsWithoutRef<T> & React.RefAttributes<HTML>>;
 
 interface ComponentProps {
-  className?: string
-  style?: React.CSSProperties
-  id?: string
-  title?: string
+  className?: string,
+  style?: React.CSSProperties,
+  id?: string,
+  title?: string,
 }
 
 interface ChildProps extends ComponentProps {
-  children?: React.JSX.Element | string
+  children?: React.JSX.Element | string,
 }
 
 interface LinkProps extends ChildProps {
-  to: string
-  newTab?: boolean
+  to: string,
+  newTab?: boolean,
 }
 
 interface ButtonProps extends ChildProps {
-  onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void
-  disabled?: boolean
-  type?: "button" | "submit" | "reset"
+  onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void,
+  disabled?: boolean,
+  type?: "button" | "submit" | "reset",
 }
 
 interface InputProps extends ComponentProps {
@@ -33,23 +31,23 @@ interface InputProps extends ComponentProps {
 }
 
 interface CharacterProps {
-  colour: import("../game/colour").Colour
-  position?: Path | null
-  isEatable?: boolean
-  spawnPosition?: DirectionalPosition | null
-  type?: import("../game/character").CharacterType
+  colour: import("../game/colour").Colour,
+  position?: Path | null,
+  isEatable?: boolean,
+  spawnPosition?: DirectionalPosition | null,
+  type?: import("../game/character").CharacterType,
 }
 
 interface BoxProps {
-  pellets?: number
-  powerPellets?: number
-  readonly colour: import("../game/colour").Colour
+  pellets?: number,
+  powerPellets?: number,
+  readonly colour: import("../game/colour").Colour,
 }
 
 interface PlayerProps {
-  readonly username: string
-  readonly pacMan?: CharacterProps
-  readonly colour: import("../game/colour").Colour
-  readonly box?: BoxProps
-  state?: import("../game/player").State
+  readonly username: string,
+  readonly pacMan?: CharacterProps,
+  readonly colour: import("../game/colour").Colour,
+  readonly box?: BoxProps,
+  state?: import("../game/player").State,
 }

pac-man-board-game/ClientApp/src/types/types.d.ts

@@ -1,68 +1,68 @@
-type MessageEventFunction<T = any> = (data: MessageEvent<T>) => void
+type MessageEventFunction<T = any> = (data: MessageEvent<T>) => void;
 
-type Setter<T> = React.Dispatch<React.SetStateAction<T>>
+type Setter<T> = React.Dispatch<React.SetStateAction<T>>;
 
-type GUID = `${string}-${string}-${string}-${string}-${string}`
+type GUID = `${string}-${string}-${string}-${string}-${string}`;
 
-type WebSocketData = string | ArrayBufferLike | Blob | ArrayBufferView
+type WebSocketData = string | ArrayBufferLike | Blob | ArrayBufferView;
 
 type ActionMessage<T = any> = {
-  readonly action: import("../utils/actions").GameAction
+  readonly action: import("../utils/actions").GameAction,
   readonly data?: T
 }
 
-type Action<T> = (obj: T) => void
+type Action<T> = (obj: T) => void;
 
-type BiAction<T1, T2> = (obj1: T1, obj2: T2) => void
+type BiAction<T1, T2> = (obj1: T1, obj2: T2) => void;
 
-type Predicate<T> = (obj: T) => boolean
+type Predicate<T> = (obj: T) => boolean;
 
 type SelectedDice = {
-  value: number
+  value: number,
   index: number
-}
+};
 
-type Position = { x: number; y: number }
+type Position = { x: number, y: number };
 
-type GameMap = number[][]
+type GameMap = number[][];
 
 type DirectionalPosition = {
-  at: Position
+  at: Position,
   direction: import("../game/direction").Direction
 }
 
 type Path = {
-  path?: Position[] | null
+  path?: Position[] | null,
   // TODO replace with DirectionalPosition
-  end: Position
+  end: Position,
   direction: import("../game/direction").Direction
 }
 
 type Game = {
-  readonly id: string
-  readonly count: number
-  readonly isGameStarted: boolean
+  readonly id: string,
+  readonly count: number,
+  readonly isGameStarted: boolean,
 }
 
 type User = {
-  readonly username: string
-  readonly password: string
+  readonly username: string,
+  readonly password: string,
   readonly colour?: import("../game/colour").Colour
 }
 
-type Api<T = ApiRequest> = (path: string, data?: ApiRequest & T) => Promise<Response>
+type Api<T = ApiRequest> = (path: string, data?: ApiRequest & T) => Promise<Response>;
 
 type ApiRequest = {
-  headers?: HeadersInit
+  headers?: HeadersInit,
   body?: any
 }
 
 type JoinGameData = {
-  readonly username: string
-  readonly gameId: GUID
+  readonly username: string,
+  readonly gameId: GUID,
 }
 
 type CreateGameData = {
-  readonly player: PlayerProps
-  readonly spawns: DirectionalPosition[]
+  readonly player: PlayerProps,
+  readonly spawns: DirectionalPosition[],
 }

pac-man-board-game/ClientApp/src/utils/actions.ts

@@ -1,10 +1,10 @@
-import Player from "../game/player"
-import { CharacterType, Ghost } from "../game/character"
-import { getCharacterSpawns } from "../game/map"
-import { TileType } from "../game/tileType"
-import { getDefaultStore } from "jotai"
-import { currentPlayerNameAtom, diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedMapAtom } from "./state"
-import { Colour } from "../game/colour"
+import Player from "../game/player";
+import {CharacterType, Ghost} from "../game/character";
+import {getCharacterSpawns} from "../game/map";
+import {TileType} from "../game/tileType";
+import {getDefaultStore} from "jotai";
+import {currentPlayerNameAtom, diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedMapAtom} from "./state";
+import {Colour} from "../game/colour";
 
 export enum GameAction {
   error,
@@ -17,112 +17,107 @@ export enum GameAction {
   // TODO add updatePellets
 }
 
-const store = getDefaultStore()
-const map = store.get(selectedMapAtom)
+const store = getDefaultStore();
+const map = store.get(selectedMapAtom);
 
-const ghostsProps: CharacterProps[] = [{ colour: Colour.purple }, { colour: Colour.purple }]
-let spawns = getCharacterSpawns(map).filter(spawn => spawn.type === CharacterType.ghost)
+const ghostsProps: CharacterProps[] = [
+  {colour: Colour.purple},
+  {colour: Colour.purple},
+];
+let spawns = getCharacterSpawns(map).filter(spawn => spawn.type === CharacterType.ghost);
 ghostsProps.forEach(ghost => {
-  ghost.spawnPosition = spawns.pop()?.position
-})
-const ghosts = ghostsProps.map(props => new Ghost(props))
+  ghost.spawnPosition = spawns.pop()?.position;
 
-store.set(ghostsAtom, ghosts)
+});
+const ghosts = ghostsProps.map(props => new Ghost(props));
+
+store.set(ghostsAtom, ghosts);
 
 export const doAction: MessageEventFunction<string> = (event): void => {
-  const message: ActionMessage = JSON.parse(event.data)
-  console.debug("Received message:", message)
+  const message: ActionMessage = JSON.parse(event.data);
+  console.debug("Received message:", message);
 
   switch (message.action as GameAction) {
     case GameAction.error:
-      console.error("Error:", message.data)
-      break
+      console.error("Error:", message.data);
+      break;
     case GameAction.rollDice:
-      setDice(message.data)
-      break
+      setDice(message.data);
+      break;
     case GameAction.moveCharacter:
-      moveCharacter(message.data)
-      break
+      moveCharacter(message.data);
+      break;
     case GameAction.joinGame:
-      joinGame(message.data)
-      break
+      joinGame(message.data);
+      break;
     case GameAction.ready:
-      ready(message.data)
-      break
+      ready(message.data);
+      break;
     case GameAction.nextPlayer:
-      nextPlayer(message.data)
-      break
+      nextPlayer(message.data);
+      break;
     case GameAction.disconnect:
-      updatePlayers(message.data)
-      break
-  }
+      updatePlayers(message.data);
+      break;
   }
+};
 
 function setDice(data?: number[]): void {
-  store.set(diceAtom, data)
+  store.set(diceAtom, data);
 }
 
-type MoveCharacterData = {
-  dice: number[]
-  players: PlayerProps[]
-  ghosts: CharacterProps[]
-  eatenPellets: Position[]
-}
+type MoveCharacterData = { dice: number[], players: PlayerProps[], ghosts: CharacterProps[], eatenPellets: Position[] };
 
 function moveCharacter(data?: MoveCharacterData): void {
-  store.set(diceAtom, data?.dice)
-  updatePlayers(data?.players)
-  updateGhosts(data)
-  removeEatenPellets(data)
+  store.set(diceAtom, data?.dice);
+  updatePlayers(data?.players);
+  updateGhosts(data);
+  removeEatenPellets(data);
 }
 
 function updatePlayers(updatedPlayers?: PlayerProps[]): void {
   if (updatedPlayers) {
-    const newList: Player[] = updatedPlayers.map(p => new Player(p))
-    store.set(playersAtom, newList)
+    const newList: Player[] = updatedPlayers.map(p => new Player(p));
+    store.set(playersAtom, newList);
   }
 }
 
 function updateGhosts(data?: MoveCharacterData): void {
-  const updatedGhosts = data?.ghosts
+  const updatedGhosts = data?.ghosts;
 
   if (updatedGhosts) {
-    const newList: Ghost[] = updatedGhosts.map(g => new Ghost(g))
-    store.set(ghostsAtom, newList)
+    const newList: Ghost[] = updatedGhosts.map(g => new Ghost(g));
+    store.set(ghostsAtom, newList);
   }
 }
 
 function removeEatenPellets(data?: MoveCharacterData): void {
-  const pellets = data?.eatenPellets
+  const pellets = data?.eatenPellets;
 
   for (const pellet of pellets ?? []) {
-    map[pellet.y][pellet.x] = TileType.empty
+    map[pellet.y][pellet.x] = TileType.empty;
   }
 }
 
-function joinGame(data?: PlayerProps[]): void {
-  // TODO missing data when refreshing page
-  const playerProps = data ?? []
-  spawns = getCharacterSpawns(map).filter(spawn => spawn.type === CharacterType.pacMan)
-  store.set(
-    playersAtom,
-    playerProps.map(p => new Player(p)),
-  )
+function joinGame(data?: PlayerProps[]): void { // TODO missing data when refreshing page
+  const playerProps = data ?? [];
+  spawns = getCharacterSpawns(map).filter(spawn => spawn.type === CharacterType.pacMan);
+  store.set(playersAtom, playerProps.map(p => new Player(p)));
 }
 
-type ReadyData = { allReady: boolean; players: PlayerProps[] }
+type ReadyData = { allReady: boolean, players: PlayerProps[] };
 
 function ready(data?: ReadyData): void {
   if (data) {
-    const players = data.players.map(p => new Player(p))
-    store.set(playersAtom, players)
+    const players = data.players.map(p => new Player(p));
+    store.set(playersAtom, players);
     if (data.allReady) {
-      store.set(currentPlayerNameAtom, data.players[0].username)
+      store.set(currentPlayerNameAtom, data.players[0].username);
     }
   }
 }
 
 function nextPlayer(currentPlayerName?: string): void {
-  store.set(currentPlayerNameAtom, currentPlayerName)
-  store.set(rollDiceButtonAtom, true)
+  store.set(currentPlayerNameAtom, currentPlayerName);
+  store.set(rollDiceButtonAtom, true);
 }

pac-man-board-game/ClientApp/src/utils/api.ts

@@ -1,27 +1,11 @@
-/**
- * getData is an asynchronous function that makes an API request to retrieve data.
- * If the mode is test, it returns a promise that resolves to an empty array.
- *
- * @param path - The path of the API endpoint.
- * @param headers - The headers to be included in the request.
- * @returns - A promise that resolves to the response from the API.
- */
 export const getData: Api = async (path, {headers} = {}) => {
-  if (import.meta.env.MODE === "test") return Promise.resolve(new Response(JSON.stringify([])))
+  if (import.meta.env.MODE === "test") return Promise.resolve(new Response(JSON.stringify([])));
   return await fetch(import.meta.env.VITE_API_HTTP + path, {
     method: "GET",
-    headers: headers,
-  })
+    headers: headers
+  });
 }
 
-/**
- * Makes a POST request to the API endpoint.
- *
- * @param path - The path of the endpoint.
- * @param body - The payload of the request.
- * @param headers - Additional headers for the request.
- * @returns - A Promise that resolves to the Response object representing the server's response.
- */
 export const postData: Api = async (path, {body, headers} = {}) => {
   return await fetch(import.meta.env.VITE_API_HTTP + path, {
     method: "POST",

pac-man-board-game/ClientApp/src/utils/state.ts

@@ -1,75 +1,74 @@
-import Player from "../game/player"
-import { atom } from "jotai"
-import { Ghost } from "../game/character"
-import { customMap } from "../game/map"
+import Player from "../game/player";
+import {atom} from "jotai";
+import {Ghost} from "../game/character";
+import {customMap} from "../game/map";
 
-const playerStorage = "player"
+const playerStorage = "player";
 /**
  * All players in the game.
  */
-export const playersAtom = atom<Player[]>([])
+export const playersAtom = atom<Player[]>([]);
 /**
  * All player characters (Pac-Man) in the game.
  */
-export const playerCharactersAtom = atom(get => get(playersAtom).map(player => player.pacMan))
+export const playerCharactersAtom = atom(get => get(playersAtom).map(player => player.pacMan));
 /**
  * All ghosts in the game.
  */
-export const ghostsAtom = atom<Ghost[]>([])
+export const ghostsAtom = atom<Ghost[]>([]);
 /**
  * All characters in the game.
  */
-export const allCharactersAtom = atom(get => [...get(playerCharactersAtom), ...get(ghostsAtom)])
+export const allCharactersAtom = atom(get => [...get(playerCharactersAtom), ...get(ghostsAtom)]);
 /**
  * The player that is currently logged in.
  */
-const playerAtom = atom<Player | undefined>(undefined)
+const playerAtom = atom<Player | undefined>(undefined);
 /**
  * Gets a getter and setter to get or set the player that is currently logged in.
  * Returns A tuple containing a getter and setter to get or set the player that is currently logged in.
  */
-export const thisPlayerAtom = atom(
-  get => {
-    const atomValue = get(playerAtom)
+export const thisPlayerAtom = atom(get => {
+  const atomValue = get(playerAtom);
   if (!atomValue) {
-      const item = sessionStorage.getItem(playerStorage)
+    const item = sessionStorage.getItem(playerStorage);
     if (item) {
-        const playerProps = JSON.parse(item) as PlayerProps
-        return new Player(playerProps)
+      const playerProps = JSON.parse(item) as PlayerProps;
+      return new Player(playerProps);
     }
   }
-    return atomValue
-  },
-  (_get, set, player: Player | undefined) => {
-    if (player) sessionStorage.setItem(playerStorage, JSON.stringify(player))
-    else sessionStorage.removeItem(playerStorage)
-    set(playerAtom, player)
-  },
-)
+  return atomValue;
+}, (_get, set, player: Player | undefined) => {
+  if (player)
+    sessionStorage.setItem(playerStorage, JSON.stringify(player));
+  else
+    sessionStorage.removeItem(playerStorage);
+  set(playerAtom, player);
+});
 /**
  * All dice that have been rolled.
  */
-export const diceAtom = atom<number[] | undefined>(undefined)
+export const diceAtom = atom<number[] | undefined>(undefined);
 /**
  * The dice that have been selected by the player.
  */
-export const selectedDiceAtom = atom<SelectedDice | undefined>(undefined)
+export const selectedDiceAtom = atom<SelectedDice | undefined>(undefined);
 /**
  * The name of the player whose turn it is.
  */
-export const currentPlayerNameAtom = atom<string | undefined>(undefined)
+export const currentPlayerNameAtom = atom<string | undefined>(undefined);
 /**
  * The player whose turn it is.
  */
 export const currentPlayerAtom = atom<Player | undefined>(get => {
-  const currentPlayerName = get(currentPlayerNameAtom)
-  return get(playersAtom).find(player => player.username === currentPlayerName)
-})
+  const currentPlayerName = get(currentPlayerNameAtom);
+  return get(playersAtom).find(player => player.username === currentPlayerName);
+});
 /**
  * Whether the roll dice button should be enabled.
  */
-export const rollDiceButtonAtom = atom(true)
+export const rollDiceButtonAtom = atom(true);
 /**
  * The map that is currently selected.
  */
-export const selectedMapAtom = atom(customMap)
+export const selectedMapAtom = atom(customMap);

pac-man-board-game/ClientApp/src/utils/utils.ts

@@ -5,14 +5,14 @@
  * @returns A promise that resolves when the predicate is true.
  */
 export function wait(predicate: Predicate<void>, timeout: number = 50): Promise<void> {
-  return new Promise<void>(resolve => {
+  return new Promise<void>((resolve) => {
     const f = () => {
       if (predicate()) {
-        return resolve()
-      }
-      setTimeout(f, timeout)
+        return resolve();
       }
+      setTimeout(f, timeout);
+    };
 
-    f()
-  })
+    f();
+  });
 }

pac-man-board-game/ClientApp/src/vite-env.d.ts

@@ -1,11 +1,11 @@
 /// <reference types="vite/client" />
 
 interface ImportMetaEnv {
-  readonly VITE_API_URI: string
-  readonly VITE_API_HTTP: string
-  readonly VITE_API_WS: string
+  readonly VITE_API_URI: string,
+  readonly VITE_API_HTTP: string,
+  readonly VITE_API_WS: string,
 }
 
 interface ImportMeta {
-  readonly env: ImportMetaEnv
+  readonly env: ImportMetaEnv;
 }

pac-man-board-game/ClientApp/src/websockets/WebSocketService.ts

@@ -1,9 +1,9 @@
-import { wait } from "../utils/utils"
+import {wait} from "../utils/utils";
 
 interface IWebSocket {
-  onOpen?: VoidFunction
-  onReceive?: MessageEventFunction
-  onClose?: VoidFunction
+  onOpen?: VoidFunction,
+  onReceive?: MessageEventFunction,
+  onClose?: VoidFunction,
   onError?: VoidFunction
 }
 
@@ -11,59 +11,59 @@ interface IWebSocket {
  * WebSocketService class provides a WebSocket client interface for easy communication with a WebSocket server.
  */
 export default class WebSocketService {
-  private ws?: WebSocket
-  private readonly _url: string
+  private ws?: WebSocket;
+  private readonly _url: string;
 
   constructor(url: string, {onOpen, onReceive, onClose, onError}: IWebSocket = {}) {
-    this._url = url
-    this._onOpen = onOpen
-    this._onReceive = onReceive
-    this._onClose = onClose
-    this._onError = onError
+    this._url = url;
+    this._onOpen = onOpen;
+    this._onReceive = onReceive;
+    this._onClose = onClose;
+    this._onError = onError;
   }
 
-  private _onOpen?: VoidFunction
+  private _onOpen?: VoidFunction;
 
   set onOpen(onOpen: VoidFunction) {
-    this._onOpen = onOpen
-    if (!this.ws) return
-    this.ws.onopen = onOpen
+    this._onOpen = onOpen;
+    if (!this.ws) return;
+    this.ws.onopen = onOpen;
   }
 
-  private _onReceive?: MessageEventFunction
+  private _onReceive?: MessageEventFunction;
 
   set onReceive(onReceive: MessageEventFunction) {
-    this._onReceive = onReceive
-    if (!this.ws) return
-    this.ws.onmessage = onReceive
+    this._onReceive = onReceive;
+    if (!this.ws) return;
+    this.ws.onmessage = onReceive;
   }
 
-  private _onClose?: VoidFunction
+  private _onClose?: VoidFunction;
 
   set onClose(onClose: VoidFunction) {
-    this._onClose = onClose
-    if (!this.ws) return
-    this.ws.onclose = onClose
+    this._onClose = onClose;
+    if (!this.ws) return;
+    this.ws.onclose = onClose;
   }
 
-  private _onError?: VoidFunction
+  private _onError?: VoidFunction;
 
   set onError(onError: VoidFunction) {
-    this._onError = onError
-    if (!this.ws) return
-    this.ws.onerror = onError
+    this._onError = onError;
+    if (!this.ws) return;
+    this.ws.onerror = onError;
   }
 
   /**
    * Opens a WebSocket connection with the specified URL and sets the event callbacks.
    */
   public open(): void {
-    if (typeof WebSocket === "undefined" || this.isConnecting()) return
-    this.ws = new WebSocket(this._url)
-    if (this._onOpen) this.ws.onopen = this._onOpen
-    if (this._onReceive) this.ws.onmessage = this._onReceive
-    if (this._onClose) this.ws.onclose = this._onClose
-    if (this._onError) this.ws.onerror = this._onError
+    if (typeof WebSocket === "undefined" || this.isConnecting()) return;
+    this.ws = new WebSocket(this._url);
+    if (this._onOpen) this.ws.onopen = this._onOpen;
+    if (this._onReceive) this.ws.onmessage = this._onReceive;
+    if (this._onClose) this.ws.onclose = this._onClose;
+    if (this._onError) this.ws.onerror = this._onError;
   }
 
   /**
@@ -72,8 +72,8 @@ export default class WebSocketService {
    * @returns {Promise<void>} - A promise that resolves when the "isOpen" condition is met.
    */
   public async waitForOpen(): Promise<void> {
-    await wait(() => this.isOpen())
-    if (this._onOpen) this.onOpen = this._onOpen
+    await wait(() => this.isOpen());
+    if (this._onOpen) this.onOpen = this._onOpen;
   }
 
   /**
@@ -83,16 +83,16 @@ export default class WebSocketService {
    */
   public send(data: ActionMessage | string): void {
     if (typeof data !== "string") {
-      data = JSON.stringify(data)
+      data = JSON.stringify(data);
     }
-    this.ws?.send(data)
+    this.ws?.send(data);
   }
 
   /**
    * Closes the WebSocket connection.
    */
   public close(): void {
-    this.ws?.close()
+    this.ws?.close();
   }
 
   /**
@@ -100,7 +100,7 @@ export default class WebSocketService {
    * @returns {boolean} Returns true if the WebSocket is open, otherwise false.
    */
   public isOpen(): boolean {
-    return this.ws?.readyState === WebSocket?.OPEN
+    return this.ws?.readyState === WebSocket?.OPEN;
   }
 
   /**
@@ -109,7 +109,7 @@ export default class WebSocketService {
    * @returns {boolean} - Returns 'true' if the WebSocket is connecting, otherwise 'false'.
    */
   public isConnecting(): boolean {
-    return this.ws?.readyState === WebSocket?.CONNECTING
+    return this.ws?.readyState === WebSocket?.CONNECTING;
   }
 
   /**
@@ -118,6 +118,6 @@ export default class WebSocketService {
    * @returns {boolean} Returns true if the WebSocket connection is closed, false otherwise.
    */
   public isClosed(): boolean {
-    return this.ws?.readyState === WebSocket?.CLOSED
+    return this.ws?.readyState === WebSocket?.CLOSED;
   }
 }

pac-man-board-game/Controllers/GameController.cs

@@ -1,6 +1,5 @@
 using System.Net.WebSockets;
 using Microsoft.AspNetCore.Mvc;
-using pacMan.DTOs;
 using pacMan.Exceptions;
 using pacMan.GameStuff;
 using pacMan.GameStuff.Items;
@@ -9,43 +8,37 @@ using pacMan.Utils;
 
 namespace pacMan.Controllers;
 
-/// <summary>
-///     Controls the game logic and handles requests related to games.
-/// </summary>
 [ApiController]
 [Route("api/[controller]")]
-public class GameController(ILogger<GameController> logger, IGameService webSocketService, IActionService actionService)
-    : GenericController(logger, webSocketService)
+public class GameController : GenericController
 {
-    [HttpGet("[action]")]
-    public override Task Connect() => base.Connect();
+    private readonly IActionService _actionService;
+    private readonly GameService _gameService;
 
-    /// <summary>
-    ///     Retrieves all games from the WebSocketService.
-    /// </summary>
-    /// <returns>
-    ///     An IEnumerable of Game objects representing all the games.
-    /// </returns>
-    [HttpGet("[action]")]
-    public IEnumerable<Game> All()
+    public GameController(ILogger<GameController> logger, GameService webSocketService, IActionService actionService) :
+        base(logger, webSocketService)
     {
-        Logger.LogDebug("Returning all games");
-        return webSocketService.Games;
+        _gameService = webSocketService;
+        _actionService = actionService;
     }
 
-    /// <summary>
-    ///     Adds a player to a game.
-    /// </summary>
-    /// <param name="gameId">The unique identifier of the game.</param>
-    /// <param name="player">The player to be joined.</param>
-    /// <returns>An IActionResult representing the result of the operation.</returns>
-    [HttpPost("[action]/{gameId:guid}")]
-    public IActionResult Join(Guid gameId, [FromBody] Player player) // TODO what if player is in a game already?
+    [HttpGet("connect")]
+    public override async Task Accept() => await base.Accept();
+
+    [HttpGet("all")]
+    public IEnumerable<Game> GetAllGames()
     {
-        Logger.LogDebug("Joining game {}", gameId);
+        Logger.Log(LogLevel.Debug, "Returning all games");
+        return _gameService.Games;
+    }
+
+    [HttpPost("join/{gameId:guid}")]
+    public IActionResult JoinGame(Guid gameId, [FromBody] Player player) // TODO what if player is in a game already?
+    {
+        Logger.Log(LogLevel.Debug, "Joining game {}", gameId);
         try
         {
-            webSocketService.JoinById(gameId, player);
+            _gameService.JoinById(gameId, player);
             return Ok("Game joined successfully");
         }
         catch (GameNotFoundException e)
@@ -58,112 +51,65 @@ public class GameController(ILogger<GameController> logger, IGameService webSock
         }
     }
 
-    /// <summary>
-    ///     Checks if a game with the specified ID exists.
-    /// </summary>
-    /// <param name="gameId">The ID of the game to check.</param>
-    /// <returns>
-    ///     Returns an <see cref="IActionResult" /> representing the result of the operation.
-    ///     If a game with the specified ID exists, returns an <see cref="OkResult" />.
-    ///     If a game with the specified ID doesn't exist, returns a <see cref="NotFoundResult" />.
-    /// </returns>
-    [HttpGet("[action]/{gameId:guid}")]
-    public IActionResult Exists(Guid gameId)
+    [HttpGet("exists/{gameId:guid}")]
+    public IActionResult GameExists(Guid gameId)
     {
-        Logger.LogDebug("Checking if game {} exists", gameId);
-        return webSocketService.Games.Any(game => game.Id == gameId) ? Ok() : NotFound();
+        Logger.Log(LogLevel.Debug, "Checking if game {} exists", gameId);
+        return _gameService.Games.Any(game => game.Id == gameId) ? Ok() : NotFound();
     }
 
-    /// <summary>
-    ///     Creates a new game and adds the specified player to it.
-    /// </summary>
-    /// <param name="data">The data required to create the game.</param>
-    /// <returns>
-    ///     Returns an <see cref="IActionResult" /> representing the result of the operation.
-    ///     If the game is successfully created, returns a <see cref="CreatedResult" /> with the game details and a location
-    ///     URL.
-    ///     If there is an error during creation, returns a <see cref="BadRequestObjectResult" /> with the error message.
-    /// </returns>
-    [HttpPost("[action]")]
-    public IActionResult Create([FromBody] CreateGameData data)
+    [HttpPost("create")]
+    public IActionResult CreateGame([FromBody] CreateGameData data)
     {
-        Logger.LogDebug("Creating game");
+        Logger.Log(LogLevel.Debug, "Creating game");
         try
         {
-            var game = webSocketService.CreateAndJoin(data.Player, data.Spawns);
+            var game = _gameService.CreateAndJoin(data.Player, data.Spawns);
             return Created($"/{game.Id}", game);
         }
         catch (Exception e)
         {
-            return BadRequest(e.Message);
+            return BadRequest(e.Message); // TODO not necessary?
         }
     }
 
     protected override Task Echo()
     {
-        actionService.WebSocket = WebSocket ?? throw new NullReferenceException("WebSocket is null");
+        _actionService.WebSocket = WebSocket ?? throw new NullReferenceException("WebSocket is null");
         return base.Echo();
     }
 
-    /// <summary>
-    ///     Runs the given WebSocketReceiveResult and byte array data to perform an action.
-    /// </summary>
-    /// <param name="result">The WebSocketReceiveResult object containing information about the received data.</param>
-    /// <param name="data">The byte array data received from the WebSocket.</param>
-    /// <returns>
-    ///     Returns an ArraySegment object representing the action response in byte array format.
-    /// </returns>
     protected override ArraySegment<byte> Run(WebSocketReceiveResult result, byte[] data)
     {
         var stringResult = data.GetString(result.Count);
 
-        Logger.LogInformation("Received: {}", stringResult);
+        Logger.Log(LogLevel.Information, "Received: {}", stringResult);
         var action = ActionMessage.FromJson(stringResult);
 
         try
         {
-            DoAction(action);
+            _actionService.DoAction(action);
         }
         catch (Exception e)
         {
-            Logger.LogError("{}", e.Message);
+            Logger.Log(LogLevel.Error, "{}", e.Message);
             action = new ActionMessage { Action = GameAction.Error, Data = e.Message };
         }
 
         return action.ToArraySegment();
     }
 
-    /// <summary>
-    ///     Sends the specified data segment.
-    /// </summary>
-    /// <param name="segment">The data segment to send.</param>
-    protected override void Send(ArraySegment<byte> segment)
+    protected override async void Send(ArraySegment<byte> segment)
     {
-        if (actionService.Game is not null)
-            actionService.SendToAll(segment);
+        if (_actionService.Game is not null)
+            _actionService.SendToAll(segment);
         else if (WebSocket is not null)
-            webSocketService.Send(WebSocket, segment);
+            await _gameService.Send(WebSocket, segment);
     }
 
     protected override ArraySegment<byte>? Disconnect() =>
-        new ActionMessage { Action = GameAction.Disconnect, Data = actionService.Disconnect() }
+        new ActionMessage { Action = GameAction.Disconnect, Data = _actionService.Disconnect() }
             .ToArraySegment();
 
-    protected override void SendDisconnectMessage(ArraySegment<byte> segment) => actionService.SendToAll(segment);
-
-    /// <summary>
-    ///     Performs the specified action based on the given message.
-    /// </summary>
-    /// <param name="message">The action message containing the action to be performed.</param>
-    public void DoAction(ActionMessage message) =>
-        message.Data = message.Action switch
-        {
-            GameAction.RollDice => actionService.RollDice(),
-            GameAction.MoveCharacter => actionService.HandleMoveCharacter(message.Data),
-            GameAction.JoinGame => actionService.FindGame(message.Data),
-            GameAction.Ready => actionService.Ready(),
-            GameAction.NextPlayer => actionService.FindNextPlayer(),
-            GameAction.Disconnect => actionService.LeaveGame(),
-            _ => message.Data
-        };
+    protected override void SendDisconnectMessage(ArraySegment<byte> segment) => _actionService.SendToAll(segment);
 }

pac-man-board-game/Controllers/GenericController.cs

@@ -1,42 +1,29 @@
 using System.Net.WebSockets;
 using Microsoft.AspNetCore.Mvc;
-using pacMan.Services;
+using pacMan.Interfaces;
 
 namespace pacMan.Controllers;
 
-/// <summary>
-///     Represents a generic controller for handling WebSocket connections.
-/// </summary>
-public abstract class GenericController(ILogger<GenericController> logger, IWebSocketService webSocketService)
-    : ControllerBase
+public abstract class GenericController : ControllerBase
 {
-    /// <summary>
-    ///     Buffer size used for processing data.
-    /// </summary>
     private const int BufferSize = 1024 * 4;
-
-    protected readonly ILogger<GenericController> Logger = logger;
+    private readonly IWebSocketService _webSocketService;
+    protected readonly ILogger<GenericController> Logger;
     protected WebSocket? WebSocket;
 
-    /// <summary>
-    ///     Establishes a WebSocket connection with the client.
-    /// </summary>
-    /// <remarks>
-    ///     This method checks if the HTTP request is a WebSocket request. If it is, it accepts the WebSocket connection, logs
-    ///     the connection establishment, and sets the WebSocket property to
-    ///     the accepted WebSocket instance.
-    ///     After the connection is established, the method calls the Echo method to start echoing messages.
-    ///     If the request is not a WebSocket request, it sets the HTTP response status code to 400 (BadRequest).
-    /// </remarks>
-    /// <returns>
-    ///     The task representing the asynchronous operation.
-    /// </returns>
-    public virtual async Task Connect()
+    protected GenericController(ILogger<GenericController> logger, IWebSocketService webSocketService)
+    {
+        Logger = logger;
+        _webSocketService = webSocketService;
+        Logger.Log(LogLevel.Debug, "WebSocket Controller created");
+    }
+
+    public virtual async Task Accept()
     {
         if (HttpContext.WebSockets.IsWebSocketRequest)
         {
             using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-            Logger.LogInformation("WebSocket connection established to {}", HttpContext.Connection.Id);
+            Logger.Log(LogLevel.Information, "WebSocket connection established to {}", HttpContext.Connection.Id);
             WebSocket = webSocket;
             await Echo();
         }
@@ -46,21 +33,16 @@ public abstract class GenericController(ILogger<GenericController> logger, IWebS
         }
     }
 
-    /// <summary>
-    ///     An asynchronous method that reads data from the WebSocket connection,
-    ///     processes it, and sends back the processed data.
-    /// </summary>
-    /// <returns>A Task representing the asynchronous operation.</returns>
     protected virtual async Task Echo()
     {
-        if (WebSocket is null) return;
+        if (WebSocket == null) return;
         try
         {
             WebSocketReceiveResult? result;
             do
             {
                 var buffer = new byte[BufferSize];
-                result = await webSocketService.Receive(WebSocket, buffer);
+                result = await _webSocketService.Receive(WebSocket, buffer);
 
                 if (result.CloseStatus.HasValue) break;
 
@@ -68,27 +50,23 @@ public abstract class GenericController(ILogger<GenericController> logger, IWebS
 
                 Send(segment);
             } while (true);
+
             var disconnectSegment = Disconnect();
-            if (disconnectSegment is not null)
+            if (disconnectSegment != null) 
                 SendDisconnectMessage((ArraySegment<byte>)disconnectSegment);
 
-            await webSocketService.Close(WebSocket, result.CloseStatus.Value, result.CloseStatusDescription);
+            await _webSocketService.Close(WebSocket, result.CloseStatus.Value, result.CloseStatusDescription);
         }
         catch (WebSocketException e)
         {
-            Logger.LogError("{}", e.Message);
+            Logger.Log(LogLevel.Error, "{}", e.Message);
         }
     }
 
-    /// <summary>
-    ///     Sends the specified byte segment using the WebSocket connection.
-    ///     If the WebSocket connection is null, the method does nothing.
-    /// </summary>
-    /// <param name="segment">The byte segment to send.</param>
-    protected virtual void Send(ArraySegment<byte> segment)
+    protected virtual async void Send(ArraySegment<byte> segment)
     {
-        if (WebSocket is null) return;
-        webSocketService.Send(WebSocket, segment);
+        if (WebSocket == null) return;
+        await _webSocketService.Send(WebSocket, segment);
     }
 
     protected abstract ArraySegment<byte> Run(WebSocketReceiveResult result, byte[] data);

pac-man-board-game/Controllers/PlayerController.cs

@@ -6,22 +6,21 @@ using pacMan.GameStuff.Items;
 namespace pacMan.Controllers;
 
 [ApiController]
-[Route("api/[controller]/[action]")]
-public class PlayerController(UserService userService) : ControllerBase
+[Route("api/[controller]")]
+public class PlayerController : ControllerBase
 {
-    /// <summary>
-    ///     Logs in a user.
-    /// </summary>
-    /// <param name="user">The user object containing the username and password.</param>
-    /// <returns>Returns an IActionResult indicating the login result.</returns>
-    [HttpPost]
+    private readonly UserService _userService;
+
+    public PlayerController(UserService userService) => _userService = userService;
+
+    [HttpPost("login")]
     public async Task<IActionResult> Login([FromBody] User user)
     {
-        var result = await userService.Login(user.Username, user.Password);
+        var result = await _userService.Login(user.Username, user.Password);
         if (result is null) return Unauthorized("Invalid username or password");
         return Ok((Player)result);
     }
 
-    [HttpPost]
-    public Task<IActionResult> Register([FromBody] User user) => throw new NotSupportedException();
+    [HttpPost("register")]
+    public async Task<IActionResult> Register([FromBody] User user) => throw new NotSupportedException();
 }

pac-man-board-game/Controllers/WsController.cs

@@ -6,11 +6,12 @@ namespace pacMan.Controllers;
 
 [ApiController]
 [Route("api/[controller]")]
-public class WsController(ILogger<WsController> logger, IWebSocketService gameService) :
-    GenericController(logger, gameService)
+public class WsController : GenericController
 {
+    public WsController(ILogger<WsController> logger, GameService gameService) : base(logger, gameService) { }
+
     [HttpGet]
-    public override async Task Connect() => await base.Connect();
+    public override async Task Accept() => await base.Accept();
 
     protected override ArraySegment<byte> Run(WebSocketReceiveResult result, byte[] data)
     {

pac-man-board-game/DTOs/DTO.cs

@@ -1,40 +0,0 @@
-using System.Text.Json.Serialization;
-using pacMan.GameStuff;
-using pacMan.GameStuff.Items;
-
-namespace pacMan.DTOs;
-
-public readonly record struct JoinGameData(
-    [property: JsonInclude, JsonPropertyName("username"), JsonRequired]
-    string Username,
-    [property: JsonInclude, JsonPropertyName("gameId"), JsonRequired]
-    Guid GameId
-)
-{
-    public void Deconstruct(out string username, out Guid gameId) => (username, gameId) = (Username, GameId);
-}
-
-public readonly record struct CreateGameData(
-    [property: JsonInclude, JsonPropertyName("player"), JsonRequired]
-    Player Player,
-    [property: JsonInclude, JsonPropertyName("spawns"), JsonRequired]
-    Queue<DirectionalPosition> Spawns
-);
-
-public readonly record struct ReadyData(
-    [property: JsonInclude, JsonPropertyName("allReady"), JsonRequired]
-    bool AllReady,
-    [property: JsonInclude, JsonPropertyName("players"), JsonRequired]
-    IEnumerable<Player> Players
-);
-
-public readonly record struct MovePlayerData(
-    [property: JsonInclude, JsonPropertyName("players"), JsonRequired]
-    List<Player> Players,
-    [property: JsonInclude, JsonPropertyName("ghosts"), JsonRequired]
-    List<Character> Ghosts,
-    [property: JsonInclude, JsonPropertyName("dice"), JsonRequired]
-    List<int> Dice,
-    [property: JsonInclude, JsonPropertyName("eatenPellets"), JsonRequired]
-    List<Position> EatenPellets
-);

pac-man-board-game/Dockerfile

@@ -1,9 +1,9 @@
-FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
+FROM mcr.microsoft.com/dotnet/aspnet:7.0 AS base
 WORKDIR /app
 EXPOSE 80
 EXPOSE 443
 
-FROM mcr.microsoft.com/dotnet/sdk:8.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
 
 RUN curl -fsSL https://deb.nodesource.com/setup_18.x | bash - \
     && apt-get install -y \

pac-man-board-game/Exceptions/GameExceptions.cs

@@ -1,5 +0,0 @@
-namespace pacMan.Exceptions;
-
-public class GameNotFoundException(string message = "Game not found") : Exception(message);
-
-public class GameNotPlayableException(string message = "Game is not allowed to be played") : Exception(message);

pac-man-board-game/Exceptions/GameNotFoundException.cs

@@ -0,0 +1,6 @@
+namespace pacMan.Exceptions;
+
+public class GameNotFoundException : Exception
+{
+    public GameNotFoundException(string message = "Game not found") : base(message) { }
+}

pac-man-board-game/Exceptions/GameNotPlayableException.cs

@@ -0,0 +1,6 @@
+namespace pacMan.Exceptions;
+
+public class GameNotPlayableException : Exception
+{
+    public GameNotPlayableException(string message = "Game is not allowed to be played") : base(message) { }
+}

pac-man-board-game/Exceptions/PlayerExceptions.cs

@@ -1,3 +0,0 @@
-namespace pacMan.Exceptions;
-
-public class PlayerNotFoundException(string? message = "Player not found") : Exception(message);

pac-man-board-game/Exceptions/PlayerNotFoundException.cs

@@ -0,0 +1,6 @@
+namespace pacMan.Exceptions;
+
+public class PlayerNotFoundException : Exception
+{
+    public PlayerNotFoundException(string? message = "Player not found") : base(message) { }
+}

pac-man-board-game/GameStuff/Actions.cs

@@ -3,9 +3,6 @@ using System.Text.Json.Serialization;
 
 namespace pacMan.GameStuff;
 
-/// <summary>
-///     Represents various actions that can be performed in a game.
-/// </summary>
 public enum GameAction
 {
     Error,
@@ -17,23 +14,13 @@ public enum GameAction
     Disconnect
 }
 
-/// <summary>
-///     Represents an action message with optional data of type <typeparamref name="T" />.
-///     Every Action may have a different type of data, or no data at all.
-/// </summary>
-/// <typeparam name="T">The type of the data.</typeparam>
 public class ActionMessage<T>
 {
     [JsonPropertyName("action")] public GameAction Action { get; init; }
 
     [JsonPropertyName("data")] public T? Data { get; set; }
 
-    /// <summary>
-    ///     Parses a JSON string into an ActionMessage object. With dynamic data.
-    /// </summary>
-    /// <param name="json">The JSON string to deserialize.</param>
-    /// <returns>An ActionMessage object populated with the deserialized data.</returns>
     public static ActionMessage FromJson(string json) => JsonSerializer.Deserialize<ActionMessage>(json)!;
 }
 
-public class ActionMessage : ActionMessage<dynamic>;
+public class ActionMessage : ActionMessage<dynamic> { }

pac-man-board-game/GameStuff/Character.cs

@@ -8,7 +8,6 @@ public class Character : IEquatable<Character>
 
     [JsonPropertyName("position")] public MovePath? Position { get; set; }
 
-    // TODO isEdible
     [JsonInclude]
     [JsonPropertyName("isEatable")]
     public bool IsEatable { get; set; } = true;
@@ -32,12 +31,9 @@ public class Character : IEquatable<Character>
         return obj.GetType() == GetType() && Equals((Character)obj);
     }
 
-    public override int GetHashCode() => HashCode.Combine(Colour, Type);
+    public override int GetHashCode() => HashCode.Combine(Colour, Position, IsEatable, SpawnPosition, (int?)Type);
 }
 
-/// <summary>
-///     Represents the types of characters in a game.
-/// </summary>
 public enum CharacterType
 {
     PacMan,

pac-man-board-game/GameStuff/Items/Box.cs

@@ -4,17 +4,10 @@ namespace pacMan.GameStuff.Items;
 
 public class Box : IEquatable<Box>
 {
-    [JsonInclude]
-    [JsonPropertyName("pellets")]
-    public int Pellets { get; init; }
+    [JsonPropertyName("pellets")] public int Pellets { get; init; }
+    [JsonPropertyName("powerPellets")] public int PowerPellet { get; init; }
 
-    [JsonInclude]
-    [JsonPropertyName("powerPellets")]
-    public int PowerPellet { get; init; }
-
-    [JsonInclude]
-    [JsonPropertyName("colour")]
-    public required string Colour { get; init; }
+    [JsonPropertyName("colour")] public required string Colour { get; init; }
 
     public bool Equals(Box? other)
     {

pac-man-board-game/GameStuff/Items/Dice.cs

@@ -6,14 +6,7 @@ public class Dice
 {
     private readonly Random _random = new();
 
-    /// <summary>
-    ///     Represents the value of the previous roll.
-    /// </summary>
-    [JsonInclude]
-    public int Value { get; private set; }
+    [JsonInclude] public int Value { get; private set; }
 
-    /// <summary>
-    ///     Rolls a dice by generating a random number between 1 and 6 and assigns it to the 'Value' property of the dice.
-    /// </summary>
     public void Roll() => Value = _random.Next(1, 7);
 }

pac-man-board-game/GameStuff/Items/DiceCup.cs

@@ -2,24 +2,18 @@ using System.Text.Json.Serialization;
 
 namespace pacMan.GameStuff.Items;
 
-/// <summary>
-///     Represents a cup containing multiple dice.
-/// </summary>
 public class DiceCup
 {
-    private readonly List<Dice> _dices = [new Dice(), new Dice()];
+    private readonly List<Dice> _dices;
 
-    /// <summary>
-    ///     Gets a list of integer values representing the values of the dices.
-    /// </summary>
-    /// <value>
-    ///     A list of integer values representing the values of the dices.
-    /// </value>
-    [JsonInclude]
-    public List<int> Values => _dices.Select(dice => dice.Value).ToList();
+    public DiceCup() =>
+        _dices = new List<Dice>
+        {
+            new(),
+            new()
+        };
+
+    [JsonInclude] public List<int> Values => _dices.Select(dice => dice.Value).ToList();
 
-    /// <summary>
-    ///     Rolls all the dice in the list.
-    /// </summary>
     public void Roll() => _dices.ForEach(dice => dice.Roll());
 }

pac-man-board-game/GameStuff/Items/Player.cs

@@ -3,9 +3,6 @@ using DAL.Database.Models;
 
 namespace pacMan.GameStuff.Items;
 
-/// <summary>
-///     Represents the various states of a 'Player'.
-/// </summary>
 public enum State
 {
     WaitingForPlayers,
@@ -14,9 +11,6 @@ public enum State
     Disconnected
 }
 
-/// <summary>
-///     Represents a player in the game.
-/// </summary>
 public class Player : IEquatable<Player>, ICloneable
 {
     [JsonPropertyName("username")] public required string Username { get; init; }

pac-man-board-game/GameStuff/Positions.cs

@@ -2,9 +2,6 @@ using System.Text.Json.Serialization;
 
 namespace pacMan.GameStuff;
 
-/// <summary>
-///     Represents a move path consisting of a sequence of positions and a target end position with a specified direction.
-/// </summary>
 public class MovePath : IEquatable<MovePath>
 {
     [JsonInclude]
@@ -22,11 +19,6 @@ public class MovePath : IEquatable<MovePath>
         return Equals(Path, other.Path) && End.Equals(other.End) && Direction == other.Direction;
     }
 
-    /// <summary>
-    ///     Converts a DirectionalPosition object to a MovePath object.
-    /// </summary>
-    /// <param name="path">The DirectionalPosition object to convert.</param>
-    /// <returns>A MovePath object with the same End and Direction as the DirectionalPosition object.</returns>
     public static implicit operator MovePath(DirectionalPosition path) =>
         new()
         {
@@ -41,12 +33,9 @@ public class MovePath : IEquatable<MovePath>
         return obj.GetType() == GetType() && Equals((MovePath)obj);
     }
 
-    public override int GetHashCode() => HashCode.Combine(End, (int)Direction);
+    public override int GetHashCode() => HashCode.Combine(Path, End, (int)Direction);
 }
 
-/// <summary>
-///     Represents a position with x and y coordinates.
-/// </summary>
 public class Position : IEquatable<Position>
 {
     [JsonPropertyName("x")] public int X { get; init; }
@@ -70,9 +59,6 @@ public class Position : IEquatable<Position>
     public override int GetHashCode() => HashCode.Combine(X, Y);
 }
 
-/// <summary>
-///     Enum representing the possible directions: Left, Up, Right, and Down.
-/// </summary>
 public enum Direction
 {
     Left,
@@ -81,9 +67,6 @@ public enum Direction
     Down
 }
 
-/// <summary>
-///     Represents a directional position with a coordinate and a direction.
-/// </summary>
 public class DirectionalPosition : IEquatable<DirectionalPosition>
 {
     [JsonPropertyName("at")] public required Position At { get; init; }
@@ -97,11 +80,6 @@ public class DirectionalPosition : IEquatable<DirectionalPosition>
         return At.Equals(other.At) && Direction == other.Direction;
     }
 
-    /// <summary>
-    ///     Converts a MovePath object to a DirectionalPosition object.
-    /// </summary>
-    /// <param name="path">The MovePath object to convert.</param>
-    /// <returns>A DirectionalPosition object representing the converted MovePath object.</returns>
     public static explicit operator DirectionalPosition(MovePath path) =>
         new()
         {

pac-man-board-game/GameStuff/Rules.cs

@@ -1,9 +1,6 @@
 namespace pacMan.GameStuff;
 
-/// <summary>
-///     The Rules class holds constant values related to the game rules.
-/// </summary>
-public static class Rules
+public class Rules
 {
     public const int MinPlayers = 2;
     public const int MaxPlayers = 4;

pac-man-board-game/Interfaces/IWebSocketService.cs

@@ -0,0 +1,10 @@
+using System.Net.WebSockets;
+
+namespace pacMan.Interfaces;
+
+public interface IWebSocketService
+{
+    Task Send(WebSocket webSocket, ArraySegment<byte> segment);
+    Task<WebSocketReceiveResult> Receive(WebSocket webSocket, byte[] buffer);
+    Task Close(WebSocket webSocket, WebSocketCloseStatus closeStatus, string? closeStatusDescription);
+}

pac-man-board-game/Program.cs

@@ -1,4 +1,5 @@
 using DAL.Database.Service;
+using pacMan.Interfaces;
 using pacMan.Services;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -7,7 +8,6 @@ var builder = WebApplication.CreateBuilder(args);
 
 builder.Services.AddControllersWithViews();
 builder.Services
-    .AddSingleton<IGameService, GameService>()
     .AddSingleton<IWebSocketService, WebSocketService>()
     .AddSingleton<GameService>()
     .AddScoped<UserService>()

pac-man-board-game/Services/ActionService.cs

@@ -1,7 +1,8 @@
 using System.Net.WebSockets;
 using System.Text.Json;
-using pacMan.DTOs;
+using System.Text.Json.Serialization;
 using pacMan.Exceptions;
+using pacMan.GameStuff;
 using pacMan.GameStuff.Items;
 
 namespace pacMan.Services;
@@ -10,10 +11,11 @@ public interface IActionService
 {
     Player Player { set; }
     Game? Game { get; set; }
-    WebSocket WebSocket { set; }
+    WebSocket? WebSocket { set; }
+    void DoAction(ActionMessage message);
     List<int> RollDice();
     List<Player> FindGame(JsonElement? jsonElement);
-    MovePlayerData HandleMoveCharacter(JsonElement? jsonElement);
+    object? HandleMoveCharacter(JsonElement? jsonElement);
     ReadyData Ready();
     string FindNextPlayer();
     List<Player> LeaveGame();
@@ -21,65 +23,68 @@ public interface IActionService
     List<Player>? Disconnect();
 }
 
-/// <summary>
-///     Provides various actions that can be performed in a game
-/// </summary>
-public class ActionService(ILogger<ActionService> logger, IGameService gameService) : IActionService
+public class ActionService : IActionService
 {
-    public WebSocket WebSocket { private get; set; } = null!;
+    private readonly GameService _gameService;
+    private readonly ILogger<ActionService> _logger;
+
+    public ActionService(ILogger<ActionService> logger, GameService gameService)
+    {
+        _logger = logger;
+        _gameService = gameService;
+    }
+
+    public WebSocket? WebSocket { private get; set; }
 
     public Game? Game { get; set; }
 
     public Player? Player { get; set; }
 
-    /// <summary>
-    ///     Rolls the dice and returns the result. If the game is null, an empty list is returned.
-    /// </summary>
-    /// <returns>A list of integers representing the values rolled on the dice.</returns>
+    public void DoAction(ActionMessage message)
+    {
+        message.Data = message.Action switch
+        {
+            GameAction.RollDice => RollDice(),
+            GameAction.MoveCharacter => HandleMoveCharacter(message.Data),
+            GameAction.JoinGame => FindGame(message.Data),
+            GameAction.Ready => Ready(),
+            GameAction.NextPlayer => FindNextPlayer(),
+            GameAction.Disconnect => LeaveGame(),
+            _ => message.Data
+        };
+    }
+
     public List<int> RollDice()
     {
         Game?.DiceCup.Roll();
-        var rolls = Game?.DiceCup.Values ?? [];
-        logger.LogInformation("Rolled [{}]", string.Join(", ", rolls));
+        var rolls = Game?.DiceCup.Values ?? new List<int>();
+        _logger.Log(LogLevel.Information, "Rolled [{}]", string.Join(", ", rolls));
 
         return rolls;
     }
 
-    /// <summary>
-    ///     Handles the movement of the character based on the provided JSON element.
-    /// </summary>
-    /// <param name="jsonElement">The JSON element containing the data to move the character.</param>
-    /// <returns>The MovePlayerData object representing the updated character movement information.</returns>
-    public MovePlayerData HandleMoveCharacter(JsonElement? jsonElement)
+    public object? HandleMoveCharacter(JsonElement? jsonElement)
     {
-        var data = jsonElement?.Deserialize<MovePlayerData>() ?? throw new NullReferenceException("Data is null");
-        if (Game is not null)
+        if (Game != null && jsonElement.HasValue)
         {
-            Game.Ghosts = data.Ghosts;
-            Game.Players = data.Players;
+            Game.Ghosts = jsonElement.Value.GetProperty("ghosts").Deserialize<List<Character>>() ??
+                          throw new NullReferenceException("Ghosts is null");
+            Game.Players = jsonElement.Value.GetProperty("players").Deserialize<List<Player>>() ??
+                           throw new NullReferenceException("Players is null");
         }
 
-        return data;
+        return jsonElement;
     }
 
-    /// <summary>
-    ///     Finds a game based on the given JSON element.
-    /// </summary>
-    /// <param name="jsonElement">The JSON data containing the username and gameId.</param>
-    /// <returns>The list of players in the found game.</returns>
-    /// <exception cref="NullReferenceException">Thrown when the JSON data is null.</exception>
-    /// <exception cref="GameNotFoundException">Thrown when the game with the given gameId does not exist.</exception>
-    /// <exception cref="PlayerNotFoundException">Thrown when the player with the given username is not found in the game.</exception>
     public List<Player> FindGame(JsonElement? jsonElement)
     {
-        var (username, gameId) =
-            jsonElement?.Deserialize<JoinGameData>() ?? throw new NullReferenceException("Data is null");
+        var data = jsonElement?.Deserialize<JoinGameData>() ?? throw new NullReferenceException("Data is null");
 
-        var game = gameService.FindGameById(gameId) ??
-                   throw new GameNotFoundException($"Game was not found, id \"{gameId}\" does not exist");
+        var game = _gameService.Games.FirstOrDefault(game => game.Id == data.GameId) ??
+                   throw new GameNotFoundException($"Game was not found, id \"{data.GameId}\" does not exist");
 
-        var player = game.FindPlayerByUsername(username) ??
-                     throw new PlayerNotFoundException($"Player \"{username}\" was not found in game");
+        var player = game.Players.Find(p => p.Username == data.Username)
+                     ?? throw new PlayerNotFoundException($"Player \"{data.Username}\" was not found in game");
 
         player.State = game.IsGameStarted ? State.InGame : State.WaitingForPlayers; // TODO doesn't work anymore
         Player = player;
@@ -89,18 +94,10 @@ public class ActionService(ILogger<ActionService> logger, IGameService gameServi
         return Game.Players;
     }
 
-    /// <summary>
-    ///     Prepares the game and returns relevant data.
-    /// </summary>
-    /// <exception cref="PlayerNotFoundException">Thrown when the player is not found.</exception>
-    /// <exception cref="GameNotFoundException">Thrown when the game is not found.</exception>
-    /// <returns>A <see cref="ReadyData" /> object containing information about game readiness.</returns>
     public ReadyData Ready()
     {
-        if (Player is null)
+        if (Player == null || Game == null)
             throw new PlayerNotFoundException("Player not found, please create a new player");
-        if (Game is null)
-            throw new GameNotFoundException();
 
         var players = Game.SetReady(Player.Username).ToArray();
         // TODO roll to start
@@ -110,55 +107,61 @@ public class ActionService(ILogger<ActionService> logger, IGameService gameServi
         return new ReadyData { AllReady = allReady, Players = players };
     }
 
-    /// <summary>
-    ///     Finds the next player in the game.
-    /// </summary>
-    /// <returns>
-    ///     The username of the next player in the game, if available.
-    /// </returns>
-    /// <exception cref="GameNotFoundException">
-    ///     Thrown if the game is not found.
-    /// </exception>
     public string FindNextPlayer() => Game?.NextPlayer().Username ?? throw new GameNotFoundException();
 
-    /// <summary>
-    ///     Removes the player from the game.
-    /// </summary>
-    /// <exception cref="NullReferenceException">Throws if the game or player is null.</exception>
-    /// <returns>A list of remaining players in the game.</returns>
     public List<Player> LeaveGame()
     {
-        if (Game is null) throw new NullReferenceException("Game is null");
-        if (Player is null) throw new NullReferenceException("Player is null");
+        if (Game == null || Player == null) throw new NullReferenceException("Game or Player is null");
         Game.RemovePlayer(Player.Username);
         return Game.Players;
     }
 
-    /// <summary>
-    ///     Disconnects the player from the game.
-    /// </summary>
-    /// <returns>
-    ///     Returns the list of players in the game after disconnecting the player.
-    ///     Returns null if the player is already disconnected or is not connected to a game.
-    /// </returns>
     public List<Player>? Disconnect()
     {
-        if (Player is null) return null;
+        if (Player == null) return null;
         Player.State = State.Disconnected;
-        if (Game is not null) Game.Connections -= SendSegment;
+        if (Game != null) Game.Connections -= SendSegment;
         return Game?.Players;
     }
 
-    /// <summary>
-    ///     Sends a given byte segment to all players in the game.
-    /// </summary>
-    /// <param name="segment">The byte segment to send.</param>
     public void SendToAll(ArraySegment<byte> segment) => Game?.SendToAll(segment);
 
-    /// <summary>
-    ///     Sends an array segment of bytes through the WebSocket connection.
-    /// </summary>
-    /// <param name="segment">The array segment of bytes to send.</param>
-    /// <returns>A task that represents the asynchronous send operation.</returns>
-    private Task SendSegment(ArraySegment<byte> segment) => gameService.Send(WebSocket, segment);
+    private async Task SendSegment(ArraySegment<byte> segment)
+    {
+        if (WebSocket != null) await _gameService.Send(WebSocket, segment);
+        else await Task.FromCanceled(new CancellationToken(true));
+    }
+}
+
+public struct JoinGameData
+{
+    [JsonInclude]
+    [JsonPropertyName("username")]
+    public required string Username { get; init; }
+
+    [JsonInclude]
+    [JsonPropertyName("gameId")]
+    public required Guid GameId { get; init; }
+}
+
+public struct CreateGameData
+{
+    [JsonInclude]
+    [JsonPropertyName("player")]
+    public required Player Player { get; init; }
+
+    [JsonInclude]
+    [JsonPropertyName("spawns")]
+    public required Queue<DirectionalPosition> Spawns { get; init; }
+}
+
+public struct ReadyData
+{
+    [JsonInclude]
+    [JsonPropertyName("allReady")]
+    public required bool AllReady { get; init; }
+
+    [JsonInclude]
+    [JsonPropertyName("players")]
+    public required IEnumerable<Player> Players { get; set; }
 }

pac-man-board-game/Services/Game.cs

@@ -5,26 +5,20 @@ using pacMan.GameStuff.Items;
 
 namespace pacMan.Services;
 
-/// <summary>
-///     Represents a game instance.
-/// </summary>
-public class Game(Queue<DirectionalPosition> spawns)
+public class Game
 {
     private readonly Random _random = new();
     private int _currentPlayerIndex;
-    private List<Player> _players = [];
+    private List<Player> _players = new();
+
+    public Game(Queue<DirectionalPosition> spawns) => Spawns = spawns;
 
     [JsonInclude] public Guid Id { get; } = Guid.NewGuid();
 
-    /// <summary>
-    ///     Gets or sets the list of players.
-    ///     When setting, the mutable values of the players are updated instead of replacing the list.
-    /// </summary>
     [JsonIgnore]
     public List<Player> Players
     {
         get => _players;
-        // TODO what if different length?
         set
         {
             if (_players.Count > 0)
@@ -40,36 +34,17 @@ public class Game(Queue<DirectionalPosition> spawns)
         }
     }
 
-    [JsonIgnore] public List<Character> Ghosts { get; set; } = []; // TODO include
+    [JsonIgnore] public List<Character> Ghosts { get; set; } = new(); // TODO include
 
-    /// <summary>
-    ///     The spawn locations on the map.
-    /// </summary>
-    /// <value>
-    ///     A Queue of DirectionalPositions representing the spawn locations on the map.
-    /// </value>
-    [JsonIgnore]
-    private Queue<DirectionalPosition> Spawns { get; } = spawns;
+    [JsonIgnore] private Queue<DirectionalPosition> Spawns { get; }
 
     [JsonIgnore] public DiceCup DiceCup { get; } = new(); // TODO include
 
     [JsonInclude] public int Count => Players.Count;
 
     // TODO edge-case when game has started but all players have disconnected, Disconnected property?
-    /// <summary>
-    ///     Whether the game has started.
-    /// </summary>
-    /// <remarks>
-    ///     The game is considered started if the count is greater than zero and at least one player is in the "InGame" state.
-    /// </remarks>
-    [JsonInclude]
-    public bool IsGameStarted => Count > 0 && Players.Any(player => player.State is State.InGame);
+    [JsonInclude] public bool IsGameStarted => Count > 0 && Players.Any(player => player.State is State.InGame);
 
-    /// <summary>
-    ///     Gets the next player in the game.
-    /// </summary>
-    /// <returns>The next player.</returns>
-    /// <exception cref="PlayerNotFoundException">Thrown when there are no players in the game.</exception>
     public Player NextPlayer()
     {
         try
@@ -78,7 +53,7 @@ public class Game(Queue<DirectionalPosition> spawns)
         }
         catch (DivideByZeroException)
         {
-            throw new PlayerNotFoundException("There are no players in the game.");
+            throw new InvalidOperationException("There are no players in the game.");
         }
 
         return Players[_currentPlayerIndex];
@@ -86,22 +61,8 @@ public class Game(Queue<DirectionalPosition> spawns)
 
     public void Shuffle() => Players.Sort((_, _) => _random.Next(-1, 2));
 
-    /// <summary>
-    ///     An event that is invoked when a message is to be sent to all connections.
-    ///     Each player in the game should be listening to this event.
-    /// </summary>
-    /// <remarks>
-    ///     The event handler is of type <see cref="Func{T, TResult}" /> which accepts an <see cref="ArraySegment{T}" /> of
-    ///     bytes and returns a <see cref="Task" />.
-    ///     This event is typically used to perform some action when something happens.
-    /// </remarks>
     public event Func<ArraySegment<byte>, Task>? Connections;
 
-    /// <summary>
-    ///     Adds a player to the game.
-    /// </summary>
-    /// <param name="player">The player to be added.</param>
-    /// <exception cref="GameNotPlayableException">Thrown when the game is already full or has already started.</exception>
     public void AddPlayer(Player player)
     {
         if (Players.Count >= Rules.MaxPlayers)
@@ -125,10 +86,6 @@ public class Game(Queue<DirectionalPosition> spawns)
         return removedPlayer;
     }
 
-    /// <summary>
-    ///     Sets the spawn position and current position of the specified player's PacMan character.
-    /// </summary>
-    /// <param name="player">The player whose PacMan character's spawn and current positions will be set.</param>
     private void SetSpawn(Player player)
     {
         if (player.PacMan.SpawnPosition is not null) return;
@@ -137,17 +94,8 @@ public class Game(Queue<DirectionalPosition> spawns)
         player.PacMan.Position = spawn;
     }
 
-    /// <summary>
-    ///     Sends the specified byte segment to all connected clients.
-    /// </summary>
-    /// <param name="segment">The byte segment to send.</param>
     public void SendToAll(ArraySegment<byte> segment) => Connections?.Invoke(segment);
 
-    /// <summary>
-    ///     Sets the state of the player with the specified username to Ready.
-    /// </summary>
-    /// <param name="username">The username of the player.</param>
-    /// <returns>All players</returns>
     public IEnumerable<Player> SetReady(string username)
     {
         var player = Players.FirstOrDefault(p => p.Username == username);
@@ -157,25 +105,11 @@ public class Game(Queue<DirectionalPosition> spawns)
         return Players;
     }
 
-    /// <summary>
-    ///     Sets all players to the "InGame" state if they are currently in the "Ready" state.
-    /// </summary>
-    /// <returns>
-    ///     Returns true if all players were successfully set to the "InGame" state, false otherwise.
-    /// </returns>
     public bool SetAllInGame()
     {
-        if (Players.Any(player => player.State is not State.Ready)) return false;
+        if (Players.Any(player => player.State != State.Ready)) return false;
 
         foreach (var player in Players) player.State = State.InGame;
         return true;
     }
-
-    /// <summary>
-    ///     Finds a player by their username.
-    /// </summary>
-    /// <param name="username">The username of the player to find.</param>
-    /// <returns>The found Player object if a player with the given username is found; otherwise, null.</returns>
-    public Player? FindPlayerByUsername(string username) =>
-        Players.FirstOrDefault(player => player.Username == username);
 }

pac-man-board-game/Services/GameService.cs

@@ -4,27 +4,20 @@ using pacMan.GameStuff.Items;
 
 namespace pacMan.Services;
 
-public interface IGameService : IWebSocketService
-{
-    SynchronizedCollection<Game> Games { get; }
-    Game JoinById(Guid id, Player player);
-    Game CreateAndJoin(Player player, Queue<DirectionalPosition> spawns);
-    Game? FindGameById(Guid id);
-    Game? FindGameByUsername(string username);
-}
-
 /// <summary>
 ///     The GameService class provides functionality for managing games in a WebSocket environment. It inherits from the
 ///     WebSocketService class.
 /// </summary>
-public class GameService(ILogger<WebSocketService> logger) : WebSocketService(logger), IGameService
+public class GameService : WebSocketService
 {
+    public GameService(ILogger<GameService> logger) : base(logger) { }
+
     /// <summary>
     ///     A thread-safe collection (SynchronizedCollection) of "Game" objects. Utilized for managing multiple game instances
     ///     simultaneously.
     ///     It represents all the current games being managed by GameService.
     /// </summary>
-    public SynchronizedCollection<Game> Games { get; } = [];
+    public SynchronizedCollection<Game> Games { get; } = new();
 
     /// <summary>
     ///     This method tries to find a game with the specified id, add a player to it and return the updated game.
@@ -64,20 +57,8 @@ public class GameService(ILogger<WebSocketService> logger) : WebSocketService(lo
         return game;
     }
 
-    /// <summary>
-    ///     Finds a game by its ID.
-    /// </summary>
-    /// <param name="id">The ID of the game.</param>
-    /// <returns>The game with the specified ID, or null if no game was found.</returns>
-    public Game? FindGameById(Guid id) => Games.FirstOrDefault(game => game.Id == id);
-
-    /// <summary>
-    ///     Finds a game by the given username.
-    /// </summary>
-    /// <param name="username">The username to search for.</param>
-    /// <returns>
-    ///     The found game, if any. Returns null if no game is found.
-    /// </returns>
-    public Game? FindGameByUsername(string username) =>
-        Games.FirstOrDefault(game => game.Players.Exists(player => player.Username == username));
+    public Game? FindGameByUsername(string username)
+    {
+        return Games.FirstOrDefault(game => game.Players.Exists(player => player.Username == username));
+    }
 }

pac-man-board-game/Services/WebSocketService.cs

@@ -1,33 +1,20 @@
 using System.Net.WebSockets;
+using pacMan.Interfaces;
 using pacMan.Utils;
 
 namespace pacMan.Services;
 
-public interface IWebSocketService
+
+public class WebSocketService : IWebSocketService
 {
-    Task Send(WebSocket webSocket, ArraySegment<byte> segment);
-    Task<WebSocketReceiveResult> Receive(WebSocket webSocket, byte[] buffer);
-    Task Close(WebSocket webSocket, WebSocketCloseStatus closeStatus, string? closeStatusDescription);
+    protected readonly ILogger<WebSocketService> Logger;
+
+    public WebSocketService(ILogger<WebSocketService> logger)
+    {
+        Logger = logger;
+        logger.Log(LogLevel.Debug, "WebSocket Service created");
     }
 
-/// <summary>
-///     WebSocketService class provides methods to send, receive and close a WebSocket connection.
-/// </summary>
-public class WebSocketService(ILogger<WebSocketService> logger) : IWebSocketService
-{
-    /// <summary>
-    ///     Sends the specified byte array as a text message through the WebSocket connection.
-    /// </summary>
-    /// <param name="webSocket">The WebSocket connection.</param>
-    /// <param name="segment">The byte array to send.</param>
-    /// <returns>
-    ///     A task representing the asynchronous operation of sending the message.
-    /// </returns>
-    /// <remarks>
-    ///     This method sends the specified byte array as a text message through the WebSocket connection.
-    ///     It uses the WebSocket.SendAsync method to send the message asynchronously.
-    ///     After sending the message, it logs a debug message using the logger provided.
-    /// </remarks>
     public async Task Send(WebSocket webSocket, ArraySegment<byte> segment)
     {
         await webSocket.SendAsync(
@@ -36,34 +23,18 @@ public class WebSocketService(ILogger<WebSocketService> logger) : IWebSocketServ
             true,
             CancellationToken.None);
 
-        logger.LogDebug("Message sent through WebSocket");
+        Logger.Log(LogLevel.Debug, "Message sent to WebSocket");
     }
 
-    /// <summary>
-    ///     Receives data from a websocket and logs a debug message.
-    /// </summary>
-    /// <param name="webSocket">The websocket to receive data from.</param>
-    /// <param name="buffer">The buffer to store the received data.</param>
-    /// <returns>
-    ///     A task representing the asynchronous operation. The result contains the <see cref="WebSocketReceiveResult" />
-    ///     which contains information about the received data.
-    /// </returns>
     public async Task<WebSocketReceiveResult> Receive(WebSocket webSocket, byte[] buffer)
     {
         var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
-        logger.LogDebug(
+        Logger.Log(LogLevel.Debug,
             "Message \"{}\" received from WebSocket",
             buffer.GetString(result.Count));
         return result;
     }
 
-    /// <summary>
-    ///     Closes the WebSocket connection with the specified close status and description.
-    /// </summary>
-    /// <param name="webSocket">The WebSocket connection to close.</param>
-    /// <param name="closeStatus">The status code indicating the reason for the close.</param>
-    /// <param name="closeStatusDescription">The optional description explaining the reason for the close.</param>
-    /// <returns>A task representing the asynchronous operation.</returns>
     public async Task Close(WebSocket webSocket, WebSocketCloseStatus closeStatus, string? closeStatusDescription)
     {
         await webSocket.CloseAsync(
@@ -71,6 +42,6 @@ public class WebSocketService(ILogger<WebSocketService> logger) : IWebSocketServ
             closeStatusDescription,
             CancellationToken.None);
 
-        logger.LogInformation("WebSocket connection closed");
+        Logger.Log(LogLevel.Information, "WebSocket connection closed");
     }
 }

pac-man-board-game/Utils/Extensions.cs

@@ -6,24 +6,13 @@ namespace pacMan.Utils;
 
 public static partial class Extensions
 {
-    /// <summary>
-    ///     Converts the specified byte array into a string using UTF-8 encoding and then removes any invalid characters.
-    /// </summary>
-    /// <param name="bytes">The byte array to convert.</param>
-    /// <param name="length">The number of bytes to decode.</param>
-    /// <returns>The decoded string without any invalid characters.</returns>
     public static string GetString(this byte[] bytes, int length)
     {
         var s = Encoding.UTF8.GetString(bytes, 0, length);
         // Removes invalid characters from the string
-        return InvalidCharacters().Replace(s, string.Empty);
+        return InvalidCharacters().Replace(s, "");
     }
 
-    /// <summary>
-    ///     Converts an object to an <see cref="ArraySegment{T}" /> of bytes.
-    /// </summary>
-    /// <param name="obj">The object to convert.</param>
-    /// <returns>An <see cref="ArraySegment{T}" /> of bytes representing the serialized object in UTF-8 encoding.</returns>
     public static ArraySegment<byte> ToArraySegment(this object obj)
     {
         var json = JsonSerializer.Serialize(obj);
@@ -31,10 +20,6 @@ public static partial class Extensions
         return new ArraySegment<byte>(bytes, 0, json.Length);
     }
 
-    /// <summary>
-    ///     Retrieves a regular expression pattern that matches invalid characters.
-    /// </summary>
-    /// <returns>A regular expression pattern for matching invalid characters.</returns>
     [GeneratedRegex("\\p{C}+")]
     private static partial Regex InvalidCharacters();
 }

pac-man-board-game/pac-man-board-game.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
     <PropertyGroup>
-        <TargetFramework>net9.0</TargetFramework>
+        <TargetFramework>net7.0</TargetFramework>
         <Nullable>enable</Nullable>
         <TypeScriptCompileBlocked>true</TypeScriptCompileBlocked>
         <TypeScriptToolsVersion>Latest</TypeScriptToolsVersion>
@@ -13,16 +13,15 @@
         <RootNamespace>pacMan</RootNamespace>
         <ImplicitUsings>enable</ImplicitUsings>
         <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
-        <LangVersion>13</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.AspNetCore.SpaProxy" Version="8.0.0"/>
-        <PackageReference Include="Microsoft.TypeScript.MSBuild" Version="5.3.3">
+        <PackageReference Include="Microsoft.AspNetCore.SpaProxy" Version="7.0.10" />
+        <PackageReference Include="Microsoft.TypeScript.MSBuild" Version="5.2.2">
           <PrivateAssets>all</PrivateAssets>
           <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="System.ServiceModel.Primitives" Version="8.0.0" />
+        <PackageReference Include="System.ServiceModel.Primitives" Version="6.1.0" />
     </ItemGroup>
 
     <ItemGroup>