👍 Updated .NET to 9 and C# to 13, comments

Dotnet8 and csharp12

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

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

BackendTests/BackendTests.csproj

@@ -1,24 +1,32 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>
         <ImplicitUsings>enable</ImplicitUsings>
         <Nullable>enable</Nullable>
 
         <IsPackable>false</IsPackable>
+
+        <LangVersion>13</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.3.2" />
+        <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.8.0"/>
-        <PackageReference Include="NSubstitute" Version="5.0.0" />
+        <PackageReference Include="NSubstitute" Version="5.1.0"/>
-        <PackageReference Include="NUnit" Version="3.13.3" />
+        <PackageReference Include="NUnit" Version="4.0.1"/>
-        <PackageReference Include="NUnit3TestAdapter" Version="4.2.1" />
+        <PackageReference Include="NUnit3TestAdapter" Version="4.5.0"/>
-        <PackageReference Include="NUnit.Analyzers" Version="3.3.0" />
+        <PackageReference Include="NUnit.Analyzers" Version="3.10.0">
-        <PackageReference Include="coverlet.collector" Version="3.1.2" />
+            <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>
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\pac-man-board-game\pac-man-board-game.csproj" />
+        <ProjectReference Include="..\pac-man-board-game\pac-man-board-game.csproj"/>
     </ItemGroup>
 
 </Project>

BackendTests/Controllers/GameControllerTests.cs

@@ -11,12 +11,10 @@ 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()
     {
@@ -27,6 +25,10 @@ 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()
     {
@@ -51,4 +53,22 @@ 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,5 +1,9 @@
+using pacMan.Controllers;
+
 namespace BackendTests.Controllers;
 
+[TestFixture]
+[TestOf(nameof(PlayerController))]
 public class PlayerControllerTests
 {
     // TODO

BackendTests/Game/Items/DiceCupTests.cs

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

BackendTests/Game/Items/DiceTests.cs

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

BackendTests/Services/ActionServiceTests.cs

@@ -2,6 +2,7 @@ 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;
@@ -9,21 +10,9 @@ using pacMan.Services;
 
 namespace BackendTests.Services;
 
+[TestFixture, TestOf(nameof(ActionService))]
 public class ActionServiceTests
 {
-    private readonly Player _blackPlayer = Players.Create("black");
-    private readonly Player _redPlayer = Players.Create("red");
-    private readonly Player _whitePlayer = Players.Create("white");
-    private ActionMessage _blackMessage = null!;
-    private pacMan.Services.Game _game = null!;
-    private GameService _gameService = null!;
-    private ActionMessage _redMessage = null!;
-    private IActionService _service = null!;
-
-    private Queue<DirectionalPosition> _spawns = null!;
-    private ActionMessage _whiteMessage = null!;
-
-
     [SetUp]
     public void Setup()
     {
@@ -36,6 +25,18 @@ public class ActionServiceTests
         _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");
+    private ActionMessage _blackMessage = null!;
+    private pacMan.Services.Game _game = null!;
+    private GameService _gameService = null!;
+    private ActionMessage _redMessage = null!;
+    private IActionService _service = null!;
+
+    private Queue<DirectionalPosition> _spawns = null!;
+    private ActionMessage _whiteMessage = null!;
+
     private JsonElement SerializeData(string username) =>
         JsonDocument.Parse(JsonSerializer.Serialize(
             new JoinGameData { Username = username, GameId = _game.Id }
@@ -50,8 +51,6 @@ public class ActionServiceTests
             new() { At = new Position { X = 9, Y = 9 }, Direction = Direction.Right }
         });
 
-    #region RollDice()
-
     [Test]
     public void RollDice_ReturnsListOfIntegers()
     {
@@ -64,10 +63,6 @@ public class ActionServiceTests
         });
     }
 
-    #endregion
-
-    #region PlayerInfo(ActionMessage message)
-
     [Test]
     public void PlayerInfo_DataIsNull()
     {
@@ -97,32 +92,6 @@ 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()
     {
@@ -183,15 +152,11 @@ 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<InvalidOperationException>(() => _service.FindNextPlayer());
+        Assert.Throws<PlayerNotFoundException>(() => _service.FindNextPlayer());
     }
 
     [Test]
@@ -221,6 +186,4 @@ public class ActionServiceTests
         var second = _service.FindNextPlayer();
         Assert.That(second, Is.EqualTo(_whitePlayer.Username));
     }
-
-    #endregion
 }

BackendTests/Services/GameServiceTests.cs

@@ -3,19 +3,14 @@ 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()
     {
@@ -29,7 +24,11 @@ public class GameServiceTests
         });
     }
 
-    #region CreateAndJoin(IPlayer player, Queue<DirectionalPosition> spawns)
+    private readonly DirectionalPosition _spawn3By3Up = new()
+        { At = new Position { X = 3, Y = 3 }, Direction = Direction.Up };
+
+    private GameService _service = null!;
+    private Queue<DirectionalPosition> _spawns = null!;
 
     [Test]
     public void CreateAndJoin_WhenEmpty()
@@ -53,15 +52,11 @@ 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 = new List<Player> { player } });
+        _service.Games.Add(new pacMan.Services.Game(_spawns) { Players = [player] });
 
         Assert.Throws<GameNotFoundException>(() => _service.JoinById(Guid.NewGuid(), player));
     }
@@ -70,7 +65,7 @@ public class GameServiceTests
     public void JoinById_WhenIdExists()
     {
         var player = Players.Create("white");
-        var game = new pacMan.Services.Game(_spawns) { Players = new List<Player> { player } };
+        var game = new pacMan.Services.Game(_spawns) { Players = [player] };
         _service.Games.Add(game);
 
 
@@ -84,6 +79,4 @@ public class GameServiceTests
             Assert.That(_service.Games, Has.Count.EqualTo(1));
         });
     }
-
-    #endregion
 }

BackendTests/Services/GameTests.cs

@@ -6,8 +6,23 @@ 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 };
 
@@ -29,20 +44,6 @@ 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);
@@ -51,18 +52,12 @@ public class GameTests
         _game.AddPlayer(_greenPlayer);
     }
 
-    #region NextPlayer()
-
     [Test]
     public void NextPlayer_WhenEmpty()
     {
-        Assert.Throws<InvalidOperationException>(() => _game.NextPlayer());
+        Assert.Throws<PlayerNotFoundException>(() => _game.NextPlayer());
     }
 
-    #endregion
-
-    #region IsGameStarted
-
     [Test]
     public void IsGameStarted_WhenEmpty()
     {
@@ -101,10 +96,6 @@ public class GameTests
         Assert.That(_game.IsGameStarted, Is.True);
     }
 
-    #endregion
-
-    #region AddPlayer(Player player)
-
     [Test]
     public void AddPlayer_WhenEmpty()
     {
@@ -157,10 +148,6 @@ public class GameTests
         Assert.Throws<GameNotPlayableException>(() => _game.AddPlayer(_greenPlayer));
     }
 
-    #endregion
-
-    #region Sendtoall(ArraySegment<byte> segment)
-
     [Test]
     public void SendToAll_WhenConnectionsIsNull()
     {
@@ -171,7 +158,6 @@ 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;
@@ -182,12 +168,11 @@ 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()
     {
@@ -222,10 +207,6 @@ public class GameTests
         Assert.Throws<PlayerNotFoundException>(() => _game.SetReady(_redPlayer.Username));
     }
 
-    #endregion
-
-    #region SetAllIngame()
-
     [Test]
     public void SetAllInGame_SetsStateToInGame()
     {
@@ -257,10 +238,6 @@ public class GameTests
         Assert.That(_game.Players, Is.Empty);
     }
 
-    #endregion
-
-    #region IsGameStarted()
-
     [Test]
     public void IsGameStarted_AllWaiting()
     {
@@ -275,6 +252,4 @@ public class GameTests
         _game.Players.ForEach(player => player.State = State.InGame);
         Assert.That(_game.IsGameStarted, Is.True);
     }
-
-    #endregion
 }

BackendTests/Services/WebSocketServiceTests.cs

@@ -1,23 +1,22 @@
 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>>());
     }
 
-    #region Send(Websocket, ArraySegment<byte>)
+    private IWebSocketService _service = null!;
 
     [Test]
     public void Send_OpenWebsocket()
@@ -48,10 +47,6 @@ public class WebSocketServiceTests
         webSocket.Received().SendAsync(segment, WebSocketMessageType.Text, true, CancellationToken.None);
     }
 
-    #endregion
-
-    #region Receive(Websocket, byte[])
-
     [Test]
     public void Receive_ExactBuffer()
     {
@@ -90,10 +85,6 @@ public class WebSocketServiceTests
         webSocket.ReceivedWithAnyArgs().ReceiveAsync(default, CancellationToken.None);
     }
 
-    #endregion
-
-    #region Close(Websocket, WebSocketCloseStatus, string?)
-
     [Test]
     public void Close_OpenWebsocket()
     {
@@ -124,6 +115,4 @@ public class WebSocketServiceTests
 
         webSocket.ReceivedWithAnyArgs().CloseAsync(default, default, CancellationToken.None);
     }
-
-    #endregion
 }

BackendTests/Utils/ExtensionsTests.cs

@@ -3,9 +3,15 @@ using pacMan.Utils;
 
 namespace BackendTests.Utils;
 
+[TestFixture]
+[TestOf(nameof(Extensions))]
 public class ExtensionsTests
 {
-    #region ToArraySegment(this object obj)
+    [SetUp]
+    public void Setup()
+    {
+        _bytes = "Hello World!"u8.ToArray();
+    }
 
     [Test]
     public void ToArraySegmentValidObject()
@@ -24,18 +30,8 @@ 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()
     {
@@ -65,6 +61,4 @@ public class ExtensionsTests
     {
         Assert.That(_bytes.GetString(_bytes.Length / 2), Is.EqualTo("Hello "));
     }
-
-    #endregion
 }

DataAccessLayer/DataAccessLayer.csproj

@@ -1,10 +1,11 @@
 <Project Sdk="Microsoft.NET.Sdk">
 
     <PropertyGroup>
-        <TargetFramework>net7.0</TargetFramework>
+        <TargetFramework>net9.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 = new()
+    private readonly List<User> _users =
-    {
+    [
         new User
         {
             Username = "Firefox",
@@ -18,10 +18,10 @@ public class UserService
             Password = "Chrome",
             Colour = "blue"
         }
-    };
+    ];
 
-    public async Task<User?> Login(string username, string password)
+    public Task<User?> Login(string username, string password)
     {
-        return await Task.Run(() => _users.FirstOrDefault(x => x.Username == username && x.Password == password));
+        return Task.Run(() => _users.FirstOrDefault(x => x.Username == username && x.Password == password));
     }
 }

README.md

@@ -11,6 +11,11 @@ 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,4 +1,6 @@
 <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: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;
+	<s:Boolean x:Key="/Default/Dpa/ExcludeFilters/=_002A_003B_002A_003BpacMan_002EControllers_002EGameController_003BConnect/@EntryIndexedValue">True</s:Boolean>
-  &lt;Project Location="/home/martin/Git/Csharp/pac-man-board-game/BackendTests" Presentation="&amp;lt;BackendTests&amp;gt;" /&gt;
+	<s:Boolean x:Key="/Default/Environment/UnitTesting/CreateUnitTestDialog/ShowAdvancedOptions/@EntryValue">True</s:Boolean>
-&lt;/SessionState&gt;</s:String></wpf:ResourceDictionary>
+	<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>

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

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

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

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

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

@@ -1,21 +1,21 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import {Navigate, Route, Routes} from "react-router-dom";
+import { Navigate, Route, Routes } from "react-router-dom"
-import Layout from "./components/layout";
+import Layout from "./components/layout"
-import AppRoutes from "./AppRoutes";
+import AppRoutes from "./AppRoutes"
-import "./index.css";
+import "./index.css"
-import {useAtomValue} from "jotai";
+import { useAtomValue } from "jotai"
-import {thisPlayerAtom} from "./utils/state";
+import { thisPlayerAtom } from "./utils/state"
 
 export const App: FC = () => (
   <Layout>
     <Routes>
       {AppRoutes.map((route, index) => {
-        const {element, secured = false, ...rest} = route;
+        const { element, secured = false, ...rest } = route
-        return <Route key={index} {...rest} element={<Secured secured={secured}>{element}</Secured>}/>;
+        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,13 +23,15 @@ 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}) => {
+    secured: boolean
-  const player = useAtomValue(thisPlayerAtom);
+  } & ChildProps
+> = ({ children, secured }) => {
+  const player = useAtomValue(thisPlayerAtom)
 
   if (secured && player === undefined) {
-    return <Navigate to={"/login"} replace/>
+    return <Navigate to={"/login"} replace />
   }
 
   return <>{children}</>

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

@@ -1,37 +1,37 @@
-import React from "react";
+import React from "react"
-import {Counter} from "./pages/counter";
+import { Counter } from "./pages/counter"
-import GamePage from "./pages/game";
+import GamePage from "./pages/game"
-import LobbyPage from "./pages/lobby";
+import LobbyPage from "./pages/lobby"
-import LoginPage from "./pages/login";
+import LoginPage from "./pages/login"
-import HomePage from "./pages/home";
+import HomePage from "./pages/home"
 
 const AppRoutes = [
   {
     index: true,
-    element: <HomePage/>
+    element: <HomePage />,
   },
   {
     path: "/counter",
-    element: <Counter/>
+    element: <Counter />,
   },
   {
     path: "/game/:id",
-    element: <GamePage/>,
+    element: <GamePage />,
-    secured: true
+    secured: true,
   },
   {
     path: "/lobby",
-    element: <LobbyPage/>,
+    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,16 +1,15 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
 
-export const Button: FC<ButtonProps> = (
+export const Button: FC<ButtonProps> = ({
-  {
+  className,
-    className,
+  onClick,
-    onClick,
+  style,
-    style,
+  title,
-    title,
+  id,
-    id,
+  disabled = false,
-    disabled = false,
+  children,
-    children,
+  type = "button",
-    type = "button",
+}) => {
-  }) => {
   return (
     <button
       id={id}
@@ -23,4 +22,4 @@ export const Button: FC<ButtonProps> = (
       {children}
     </button>
   )
-}
+}

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

@@ -1,36 +1,34 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import useToggle from "../hooks/useToggle";
+import useToggle from "../hooks/useToggle"
-import {BugAntIcon} from "@heroicons/react/20/solid";
+import { BugAntIcon } from "@heroicons/react/20/solid"
-import {selectedMapAtom} from "../utils/state";
+import { selectedMapAtom } from "../utils/state"
-import {useAtom} from "jotai";
+import { useAtom } from "jotai"
 
 const DebugMenu: FC = () => {
-
+  const [open, toggleOpen] = useToggle()
-  const [open, toggleOpen] = useToggle();
 
   if (import.meta.env.DEV) {
     return (
       <div>
-        {open && <DebugOptions/>}
+        {open && <DebugOptions />}
-        <button className={"fixed bottom-2 right-2 bg-gray-800 text-white p-2 z-50 rounded-full"}
+        <button
-                title={"Debug menu"}
+          className={"fixed bottom-2 right-2 bg-gray-800 text-white p-2 z-50 rounded-full"}
-                onClick={() => toggleOpen()}>
+          title={"Debug menu"}
-          <BugAntIcon className={"w-8 m-1"}/>
+          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,56 +1,49 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import {useAtom, useAtomValue} from "jotai";
+import { useAtom, useAtomValue } from "jotai"
-import {selectedDiceAtom, thisPlayerAtom,} from "../utils/state";
+import { selectedDiceAtom, thisPlayerAtom } from "../utils/state"
-import {Button} from "./button";
+import { Button } from "./button"
 
-export const AllDice: FC<{ values?: number[] } & ComponentProps> = (
+export const AllDice: FC<{ values?: number[] } & ComponentProps> = ({ className, values }) => {
-  {
+  const [selectedDice, setSelectedDice] = useAtom(selectedDiceAtom)
-    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) =>
+      {values?.map((value, index) => (
-        <Dice key={index}
+        <Dice
-              className={`${selectedDice?.index === index ? "border-2 border-black" : ""} ${className}`}
+          key={index}
-              value={value}
+          className={`${selectedDice?.index === index ? "border-2 border-black" : ""} ${className}`}
-              onClick={(value) => handleClick({index, value})}/>)}
+          value={value}
+          onClick={value => handleClick({ index, value })}
+        />
+      ))}
     </div>
-  );
+  )
-};
-
-interface DiceProps extends ComponentProps {
-  value?: number,
-  onClick?: (value: number) => void,
 }
 
-export const Dice: FC<DiceProps> = (
+interface DiceProps extends ComponentProps {
-  {
+  value?: number
-    className,
+  onClick?: (value: number) => void
-    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
-            disabled={!thisPlayer?.isTurn()}
+      className={`text-2xl bg-gray-400 px-4 m-1 ${className}`}
-            onClick={handleClick}>
+      disabled={!thisPlayer?.isTurn()}
+      onClick={handleClick}>
       {value?.toString()}
     </Button>
-  );
+  )
-};
+}

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

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

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

@@ -1,147 +1,138 @@
-import React, {FC, Fragment, useEffect, useState} from "react";
+import React, { FC, Fragment, useEffect, useState } from "react"
-import {Character} from "../game/character";
+import { Character } from "../game/character"
-import findPossiblePositions from "../game/possibleMovesAlgorithm";
+import findPossiblePositions from "../game/possibleMovesAlgorithm"
-import {GameTile} from "./gameTile";
+import { GameTile } from "./gameTile"
-import {TileType} from "../game/tileType";
+import { TileType } from "../game/tileType"
-import {atom, useAtom, useAtomValue, useSetAtom} from "jotai";
+import { atom, useAtom, useAtomValue, useSetAtom } from "jotai"
-import {allCharactersAtom, currentPlayerAtom, playersAtom, selectedDiceAtom} from "../utils/state";
+import { allCharactersAtom, currentPlayerAtom, playersAtom, selectedDiceAtom } from "../utils/state"
-import {Dialog, Transition} from "@headlessui/react";
+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> = (
+const Board: FC<BoardProps> = ({ className, onMove, map }) => {
-  {
+  const currentPlayer = useAtomValue(currentPlayerAtom)
-    className,
+  const characters = useAtomValue(allCharactersAtom)
-    onMove,
+  const selectedDice = useAtomValue(selectedDiceAtom)
-    map
+  const [selectedCharacter, setSelectedCharacter] = useState<Character>()
-  }) => {
+  const [possiblePositions, setPossiblePositions] = useState<Path[]>([])
-
+  const [hoveredPosition, setHoveredPosition] = useState<Path>()
-  const currentPlayer = useAtomValue(currentPlayerAtom);
+  const setModalOpen = useSetAtom(modalOpenAtom)
-  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);
+      const positions = pickUpPellets(destination)
-      onMove?.(positions);
+      onMove?.(positions)
-      setSelectedCharacter(undefined);
+      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();
+      takenChar.moveToSpawn()
-      stealFromPlayer();
+      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]) {
-      for (const tile of [...destination.path ?? [], destination.end]) {
+        const currentTile = map[tile.y][tile.x]
-        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;
+          map[tile.y][tile.x] = TileType.empty
-          positions.push(tile);
+          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);
+      const possiblePaths = findPossiblePositions(map, selectedCharacter, selectedDice.value, characters)
-      setPossiblePositions(possiblePaths);
+      setPossiblePositions(possiblePaths)
     } else {
-      setPossiblePositions([]);
+      setPossiblePositions([])
     }
-  }, [selectedCharacter, selectedDice]);
+  }, [selectedCharacter, selectedDice])
 
   return (
     <div className={`w-fit ${className}`}>
-      <SelectPlayerModal/>
+      <SelectPlayerModal />
-      {
+      {map.map((row, rowIndex) => (
-        map.map((row, rowIndex) =>
+        <div key={rowIndex} className={"flex"}>
-          <div key={rowIndex} className={"flex"}>
+          {row.map((tile, colIndex) => (
-            {
+            <GameTile
-              row.map((tile, colIndex) =>
+              key={colIndex + rowIndex * colIndex}
-                <GameTile
+              type={tile}
-                  key={colIndex + rowIndex * colIndex}
+              possiblePath={possiblePositions.find(p => p.end.x === colIndex && p.end.y === rowIndex)}
-                  type={tile}
+              character={characters.find(c => c.isAt({ x: colIndex, y: rowIndex }))}
-                  possiblePath={possiblePositions.find(p => p.end.x === colIndex && p.end.y === rowIndex)}
+              isSelected={selectedCharacter?.isAt({ x: colIndex, y: rowIndex })}
-                  character={characters.find(c => c.isAt({x: colIndex, y: rowIndex}))}
+              showPath={hoveredPosition?.path?.find(pos => pos.x === colIndex && pos.y === rowIndex) !== undefined}
-                  isSelected={selectedCharacter?.isAt({x: colIndex, y: rowIndex})}
+              handleMoveCharacter={handleMoveCharacter}
-                  showPath={hoveredPosition?.path?.find(pos => pos.x === colIndex && pos.y === rowIndex) !== undefined}
+              handleSelectCharacter={handleSelectCharacter}
-                  handleMoveCharacter={handleMoveCharacter}
+              handleStartShowPath={handleShowPath}
-                  handleSelectCharacter={handleSelectCharacter}
+              handleStopShowPath={() => setHoveredPosition(undefined)}
-                  handleStartShowPath={handleShowPath}
+            />
-                  handleStopShowPath={() => setHoveredPosition(undefined)}/>
+          ))}
-              )
+        </div>
-            }
+      ))}
-          </div>)
-      }
     </div>
-  );
+  )
-};
+}
 
-export default Board;
+export default Board
 
 const SelectPlayerModal: FC = () => {
-  const [isOpen, setIsOpen] = useAtom(modalOpenAtom);
+  const [isOpen, setIsOpen] = useAtom(modalOpenAtom)
-  const currentPlayer = useAtomValue(currentPlayerAtom);
+  const currentPlayer = useAtomValue(currentPlayerAtom)
-  const allPlayers = useAtomValue(playersAtom).filter(p => p !== currentPlayer);
+  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 (
@@ -155,9 +146,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" />
-            <div className="fixed inset-0 bg-black bg-opacity-25"/>
           </Transition.Child>
 
           <div className="fixed inset-0 overflow-y-auto">
@@ -169,10 +159,8 @@ const SelectPlayerModal: FC = () => {
                 enterTo="opacity-100 scale-100"
                 leave="ease-in duration-200"
                 leaveFrom="opacity-100 scale-100"
-                leaveTo="opacity-0 scale-95"
+                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.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>
@@ -182,29 +170,29 @@ const SelectPlayerModal: FC = () => {
                     </Dialog.Description>
                   </div>
 
-                  {
+                  {allPlayers.map(player => (
-                    allPlayers.map(player =>
+                    <div key={player.username} className={"border-b pb-1"}>
-                      <div key={player.username} className={"border-b pb-1"}>
+                      <span className={"mx-2"}>
-                        <span className={"mx-2"}>{player.username} has {player.box.pellets} pellets</span>
+                        {player.username} has {player.box.pellets} pellets
-                        <button className={"text-blue-500 enabled:cursor-pointer disabled:text-gray-500"}
+                      </span>
-                                style={{background: "none"}}
+                      <button
-                                disabled={player.box.pellets === 0}
+                        className={"text-blue-500 enabled:cursor-pointer disabled:text-gray-500"}
-                                onClick={() => {
+                        style={{ background: "none" }}
-                                  currentPlayer?.stealFrom(player);
+                        disabled={player.box.pellets === 0}
-                                  close();
+                        onClick={() => {
-                                }}>
+                          currentPlayer?.stealFrom(player)
-                          Steal
+                          close()
-                        </button>
+                        }}>
-                      </div>
+                        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,33 +1,36 @@
-import React, {FC, MouseEventHandler} from "react";
+import React, { FC, MouseEventHandler } from "react"
-import {State} from "../game/player";
+import { State } from "../game/player"
-import {currentPlayerAtom, playersAtom, rollDiceButtonAtom, thisPlayerAtom} from "../utils/state";
+import { currentPlayerAtom, playersAtom, rollDiceButtonAtom, thisPlayerAtom } from "../utils/state"
-import {useAtomValue} from "jotai";
+import { useAtomValue } from "jotai"
-import {Button} from "./button";
+import { Button } from "./button"
-import rules from "../game/rules";
+import rules from "../game/rules"
 
 interface GameButtonProps extends ComponentProps {
-  onReadyClick?: MouseEventHandler,
+  onReadyClick?: MouseEventHandler
   onRollDiceClick?: MouseEventHandler
 }
 
-const GameButton: FC<GameButtonProps> = (
+const GameButton: FC<GameButtonProps> = ({ onReadyClick, onRollDiceClick }) => {
-  {
+  const currentPlayer = useAtomValue(currentPlayerAtom)
-    onReadyClick,
+  const thisPlayer = useAtomValue(thisPlayerAtom)
-    onRollDiceClick,
+  const players = useAtomValue(playersAtom)
-  }) => {
+  const activeRollDiceButton = useAtomValue(rollDiceButtonAtom)
 
-  const currentPlayer = useAtomValue(currentPlayerAtom);
+  if (
-  const thisPlayer = useAtomValue(thisPlayerAtom);
+    players.length >= rules.minPlayers &&
-  const players = useAtomValue(playersAtom);
+    (currentPlayer === undefined || currentPlayer.state === State.waitingForPlayers)
-  const activeRollDiceButton = useAtomValue(rollDiceButtonAtom);
+  ) {
-
+    return <Button onClick={onReadyClick}>Ready</Button>
-  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
+  if (!thisPlayer?.isTurn()) {
-    return <Button disabled>Please wait</Button>;
+    // TODO also show when waiting for other players
+    return <Button disabled>Please wait</Button>
   }
-  return <Button onClick={onRollDiceClick} disabled={!activeRollDiceButton}>Roll dice</Button>;
+  return (
-};
+    <Button onClick={onRollDiceClick} disabled={!activeRollDiceButton}>
+      Roll dice
+    </Button>
+  )
+}
 
-export default GameButton;
+export default GameButton

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

@@ -1,39 +1,46 @@
-import React, {FC, useEffect} from "react";
+import React, { FC, useEffect } from "react"
-import {AllDice} from "./dice";
+import { AllDice } from "./dice"
-import {doAction, GameAction} from "../utils/actions";
+import { doAction, GameAction } from "../utils/actions"
-import GameBoard from "./gameBoard";
+import GameBoard from "./gameBoard"
-import WebSocketService from "../websockets/WebSocketService";
+import WebSocketService from "../websockets/WebSocketService"
-import Player from "../game/player";
+import Player from "../game/player"
-import PlayerStats from "../components/playerStats";
+import PlayerStats from "../components/playerStats"
-import {useAtom, useAtomValue, useSetAtom} from "jotai";
+import { useAtom, useAtomValue, useSetAtom } from "jotai"
-import {diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedDiceAtom} from "../utils/state";
+import { diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedDiceAtom } from "../utils/state"
-import GameButton from "./gameButton";
+import GameButton from "./gameButton"
-import {Button} from "./button";
+import { Button } from "./button"
-import {useNavigate, useParams} from "react-router-dom";
+import { useNavigate, useParams } from "react-router-dom"
-import {getData} from "../utils/api";
+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)
 
-export const GameComponent: FC<{ player: Player, map: GameMap }> = ({player, map}) => {
+/**
+ * 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)
 
-  const players = useAtomValue(playersAtom);
+  const navigate = useNavigate()
-  const dice = useAtomValue(diceAtom);
+  const { id } = useParams()
-  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);
+    setSelectedDice(undefined)
-    wsService.send({action: GameAction.rollDice});
+    wsService.send({ action: GameAction.rollDice })
-    setActiveRollDiceButton(false);
+    setActiveRollDiceButton(false)
   }
 
   /**
@@ -42,22 +49,22 @@ export const GameComponent: FC<{ player: Player, map: GameMap }> = ({player, map
    */
   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()
     }
   }
 
@@ -70,15 +77,15 @@ export const GameComponent: FC<{ player: Player, map: GameMap }> = ({player, map
       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 })
   }
 
   /**
@@ -86,44 +93,40 @@ export const GameComponent: FC<{ player: Player, map: GameMap }> = ({player, map
    * 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});
+    wsService.send({ action: GameAction.disconnect })
-    navigate("/lobby");
+    navigate("/lobby")
   }
 
   useEffect(() => {
+    getData(`/game/exists/${id}`).then(res => {
+      if (!res.ok) {
+        return navigate("/lobby")
+      }
+      wsService.onReceive = doAction
+      wsService.open()
 
-    getData(`/game/exists/${id}`)
+      wsService.waitForOpen().then(() => joinGame())
-      .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"}>
+      <div className={"flex justify-center"}>{players?.map(p => <PlayerStats key={p.username} player={p} />)}</div>
-        {players?.map(p => <PlayerStats key={p.username} player={p}/>)}
-      </div>
       <div className={"flex-center"}>
-        <GameButton onReadyClick={sendReady} onRollDiceClick={rollDice}/>
+        <GameButton onReadyClick={sendReady} onRollDiceClick={rollDice} />
       </div>
-      <AllDice values={dice}/>
+      <AllDice values={dice} />
-      <GameBoard className={"mx-auto my-2"} onMove={onCharacterMove} map={map}/>
+      <GameBoard className={"mx-auto my-2"} onMove={onCharacterMove} map={map} />
     </>
-  );
+  )
-};
+}

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

@@ -1,165 +1,151 @@
-import React, {FC, useEffect, useState} from "react";
+import React, { FC, useEffect, useState } from "react"
-import {TileType} from "../game/tileType";
+import { TileType } from "../game/tileType"
-import {Character, Dummy} from "../game/character";
+import { Character, Dummy } from "../game/character"
-import {Direction} from "../game/direction";
+import { Direction } from "../game/direction"
-import {Colour} from "../game/colour";
+import { Colour } from "../game/colour"
 
 interface TileWithCharacterProps extends ComponentProps {
-  possiblePath?: Path,
+  possiblePath?: Path
-  character?: Character,
+  character?: Character
-  type?: TileType,
+  type?: TileType
-  handleMoveCharacter?: Action<Path>,
+  handleMoveCharacter?: Action<Path>
-  handleSelectCharacter?: Action<Character>,
+  handleSelectCharacter?: Action<Character>
-  handleStartShowPath?: Action<Path>,
+  handleStartShowPath?: Action<Path>
-  handleStopShowPath?: VoidFunction,
+  handleStopShowPath?: VoidFunction
-  isSelected?: boolean,
+  isSelected?: boolean
   showPath?: boolean
 }
 
-export const GameTile: FC<TileWithCharacterProps> = (
+export const GameTile: FC<TileWithCharacterProps> = ({
-  {
+  possiblePath,
-    possiblePath,
+  character,
-    character,
+  type,
-    type,
+  handleMoveCharacter,
-    handleMoveCharacter,
+  handleSelectCharacter,
-    handleSelectCharacter,
+  handleStartShowPath,
-    handleStartShowPath,
+  handleStopShowPath,
-    handleStopShowPath,
+  isSelected = false,
-    isSelected = false,
+  showPath = false,
-    showPath = false
+}) => (
-  }) => (
+  <Tile
-  <Tile className={`${possiblePath?.end ? "border-4 border-white" : ""}`}
+    className={`${possiblePath?.end && "border-4 border-white"}`}
-        type={type}
+    type={type}
-        onClick={possiblePath ? () => handleMoveCharacter?.(possiblePath) : undefined}
+    onClick={possiblePath ? () => handleMoveCharacter?.(possiblePath) : undefined}
-        onMouseEnter={possiblePath ? () => handleStartShowPath?.(possiblePath) : undefined}
+    onMouseEnter={possiblePath ? () => handleStartShowPath?.(possiblePath) : undefined}
-        onMouseLeave={handleStopShowPath}>
+    onMouseLeave={handleStopShowPath}>
     <>
-      {character &&
+      {character && (
-          <div className={"flex-center wh-full"}>
+        <div className={"flex-center wh-full"}>
-              <CharacterComponent
+          <CharacterComponent
-                  character={character}
+            character={character}
-                  onClick={handleSelectCharacter}
+            onClick={handleSelectCharacter}
-                  className={isSelected ? "animate-bounce" : ""}/>
+            className={isSelected ? "animate-bounce" : ""}
-          </div>
+          />
-      }
+        </div>
-      {showPath && <Circle/>}
+      )}
-      <AddDummy path={possiblePath}/>
+      {showPath && <Circle />}
+      <AddDummy path={possiblePath} />
     </>
   </Tile>
-);
+)
 
-const Circle: FC<{ colour?: Colour } & ComponentProps> = ({colour = Colour.white, className}) => (
+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`}
+    <div className={`w-1/2 h-1/2 rounded-full`} style={{ backgroundColor: colour }} />
-         style={{backgroundColor: colour}}/>
   </div>
-);
+)
 
 interface TileProps extends ChildProps {
-  type?: TileType,
+  type?: TileType
-  onClick?: VoidFunction,
+  onClick?: VoidFunction
-  onMouseEnter?: VoidFunction,
+  onMouseEnter?: VoidFunction
-  onMouseLeave?: VoidFunction,
+  onMouseLeave?: VoidFunction
-  character?: Character,
+  character?: Character
-  onCharacterClick?: Action<Character>,
+  onCharacterClick?: Action<Character>
-  characterClass?: string,
+  characterClass?: string
 }
 
-const Tile: FC<TileProps> = (
+const Tile: FC<TileProps> = ({ type = TileType.empty, onClick, onMouseEnter, onMouseLeave, className, children }) => {
-  {
+  const [tileSize, setTileSize] = useState(2)
-    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);
+      const newSize = Math.floor(window.innerWidth / 16)
-      setTileSize(newSize);
+      setTileSize(newSize)
     }
 
-    handleResize();
+    handleResize()
 
-    window.addEventListener("resize", handleResize);
+    window.addEventListener("resize", handleResize)
-    return () => window.removeEventListener("resize", handleResize);
+    return () => window.removeEventListener("resize", handleResize)
-  }, []);
+  }, [])
 
   return (
-    <div className={`${setColor()} hover:border relative max-w-[75px] max-h-[75px] ${className}`}
+    <div
-         style={{width: `${tileSize}px`, height: `${tileSize}px`}}
+      className={`${setColor()} hover:border relative max-w-[75px] max-h-[75px] ${className}`}
-         onClick={onClick}
+      style={{ width: `${tileSize}px`, height: `${tileSize}px` }}
-         onMouseEnter={onMouseEnter}
+      onClick={onClick}
-         onMouseLeave={onMouseLeave}>
+      onMouseEnter={onMouseEnter}
+      onMouseLeave={onMouseLeave}>
       {children}
-      {type === TileType.pellet && <Circle colour={Colour.yellow}/>}
+      {type === TileType.pellet && <Circle colour={Colour.yellow} />}
-      {type === TileType.powerPellet && <Circle colour={Colour.red}/>}
+      {type === TileType.powerPellet && <Circle colour={Colour.red} />}
     </div>
-  );
+  )
-};
-
-const AddDummy: FC<{ path?: Path } & ComponentProps> = ({path}) => (
-  <>
-    {path &&
-        <div className={"flex-center wh-full"}>
-            <CharacterComponent character={new Dummy(path)}/>
-        </div>
-    }
-  </>
-);
-
-interface CharacterComponentProps extends ComponentProps {
-  character?: Character,
-  onClick?: Action<Character>,
 }
 
-const CharacterComponent: FC<CharacterComponentProps> = (
+const AddDummy: FC<{ path?: Path } & ComponentProps> = ({ path }) => (
-  {
+  <>
-    character,
+    {path && (
-    onClick,
+      <div className={"flex-center wh-full"}>
-    className
+        <CharacterComponent character={new Dummy(path)} />
-  }) => {
+      </div>
+    )}
+  </>
+)
 
+interface CharacterComponentProps extends ComponentProps {
+  character?: Character
+  onClick?: Action<Character>
+}
+
+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
-         style={{backgroundColor: `${character.colour}`}}
+      className={`rounded-full w-4/5 h-4/5 cursor-pointer hover:border border-black relative ${className}`}
-         onClick={() => onClick?.(character)}>
+      style={{ backgroundColor: `${character.colour}` }}
+      onClick={() => onClick?.(character)}>
       <div>
-        <div className={`absolute ${getSide()} w-1/2 h-1/2 rounded-full bg-black`}/>
+        <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,23 +1,18 @@
-import React, {forwardRef} from "react";
+import React, { forwardRef } from "react"
 
-const Input: FRComponent<InputProps, HTMLInputElement> = forwardRef((
+const Input: FRComponent<InputProps, HTMLInputElement> = forwardRef(
-  {
+  ({ type = "text", className, id, placeholder, required = false, name, autoComplete = "off" }, ref) => (
-    type = "text",
+    <input
-    className,
+      type={type}
-    id,
+      autoComplete={autoComplete}
-    placeholder,
+      ref={ref}
-    required = false,
+      id={id}
-    name,
+      name={name}
-    autoComplete = "off",
+      className={"border-2 border-gray-300 rounded-md p-1 " + className}
-  }, ref) => (
+      placeholder={placeholder}
-  <input type={type}
+      required={required}
-         autoComplete={autoComplete}
+    />
-         ref={ref}
+  ),
-         id={id}
+)
-         name={name}
-         className={"border-2 border-gray-300 rounded-md p-1 " + className}
-         placeholder={placeholder}
-         required={required}/>
-));
 
-export default Input;
+export default Input

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

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

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

@@ -1,84 +1,89 @@
-import React, {FC, useEffect} from "react";
+import React, { FC, useEffect } from "react"
-import {Link, useNavigate} from "react-router-dom";
+import { Link, useNavigate } from "react-router-dom"
-import {useAtom, useAtomValue} from "jotai";
+import { useAtom, useAtomValue } from "jotai"
-import {thisPlayerAtom} from "../utils/state";
+import { thisPlayerAtom } from "../utils/state"
-import {UserCircleIcon} from "@heroicons/react/24/outline";
+import { UserCircleIcon } from "@heroicons/react/24/outline"
-import useToggle from "../hooks/useToggle";
+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 ? (
-            player === undefined ?
+            <NavItem className={"mx-2"} to={"/login"}>
-              <NavItem className={"mx-2"} to={"/login"}>Login</NavItem>
+              Login
-              :
+            </NavItem>
-              <>
+          ) : (
-                <NavItem to={"/lobby"}>Lobby</NavItem>
+            <>
-                <ProfileDropdown className={"mx-2"}/>
+              <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}) => (
+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 ProfileDropdown: FC<ComponentProps> = ({ className }) => {
-  const [player, setPlayer] = useAtom(thisPlayerAtom);
+  const [player, setPlayer] = useAtom(thisPlayerAtom)
-  const [isOpened, toggleOpen] = useToggle();
+  const [isOpened, toggleOpen] = useToggle()
-  const navigate = useNavigate();
+  const navigate = useNavigate()
 
   async function logout(): Promise<void> {
-    setPlayer(undefined);
+    setPlayer(undefined)
-    navigate("/login");
+    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);
+      document.addEventListener("click", closeIfOutsideButton)
-      return () => document.removeEventListener("click", closeIfOutsideButton);
+      return () => document.removeEventListener("click", closeIfOutsideButton)
     }
-
+  }, [isOpened])
-  }, [isOpened]);
 
   return (
     <>
-      <li id={"profile-dropdown"}
+      <li
-          className={`inline-flex-center cursor-pointer hover:bg-gray-100 h-full px-2 ${className}`}
+        id={"profile-dropdown"}
-          onClick={() => toggleOpen()}>
+        className={`inline-flex-center cursor-pointer hover:bg-gray-100 h-full px-2 ${className}`}
-        <UserCircleIcon className={"w-7"}/>
+        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"}>
-          <div className={"absolute right-2 border rounded-b -bottom-9 px-5"}>
+          <button onClick={logout} className={"hover:underline py-1"}>
-              <button onClick={logout} className={"hover:underline py-1"}>Logout</button>
+            Logout
-          </div>
+          </button>
-      }
+        </div>
+      )}
     </>
   )
 }

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

@@ -1,29 +1,27 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import Player, {State} from "../game/player";
+import Player, { State } from "../game/player"
-import {useAtomValue} from "jotai";
+import { useAtomValue } from "jotai"
-import {currentPlayerNameAtom} from "../utils/state";
+import { currentPlayerNameAtom } from "../utils/state"
 
-const PlayerStats: FC<{ player: Player } & ComponentProps> = (
+const PlayerStats: FC<{ player: Player } & ComponentProps> = ({ player, className, id }) => {
-  {
+  const currentPlayerName = useAtomValue(currentPlayerNameAtom)
-    player,
-    className,
-    id
-  }) => {
-  const currentPlayerName = useAtomValue(currentPlayerNameAtom);
   return (
-    <div key={player.colour}
+    <div
-         className={`w-fit m-2 ${player.state === State.disconnected ? "text-gray-500" : ""} ${className}`} id={id}>
+      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,32 +1,31 @@
 export default class Box implements BoxProps {
-  public readonly colour;
+  public readonly colour
-  public pellets;
+  public pellets
-  public powerPellets;
+  public powerPellets
 
-  public constructor({colour, pellets = 0, powerPellets = 0}: BoxProps) {
+  public constructor({ colour, pellets = 0, powerPellets = 0 }: BoxProps) {
-    this.colour = colour;
+    this.colour = colour
-    this.pellets = pellets;
+    this.pellets = pellets
-    this.powerPellets = powerPellets;
+    this.powerPellets = powerPellets
   }
 
   public addPellet(): void {
-    this.pellets++;
+    this.pellets++
   }
 
   public removePellet(): boolean {
-    if (this.pellets <= 0) return false;
+    if (this.pellets <= 0) return false
-    this.pellets--;
+    this.pellets--
-    return true;
+    return true
   }
 
   public addPowerPellet(): void {
-    this.powerPellets++;
+    this.powerPellets++
   }
 
   public removePowerPellet(): boolean {
-    if (this.powerPellets <= 0) return false;
+    if (this.powerPellets <= 0) return false
-    this.powerPellets--;
+    this.powerPellets--
-    return true;
+    return true
   }
-
 }

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

@@ -1,5 +1,5 @@
-import {Direction} from "./direction";
+import { Direction } from "./direction"
-import {Colour} from "./colour";
+import { Colour } from "./colour"
 
 export enum CharacterType {
   pacMan,
@@ -8,89 +8,106 @@ export enum CharacterType {
 }
 
 export class Character implements CharacterProps {
-  public readonly colour;
+  public readonly colour
-  public position;
+  public position
-  public isEatable;
+  public isEatable
-  public readonly spawnPosition;
+  public readonly spawnPosition
-  public readonly type;
+  public readonly type
 
-  public constructor(
+  public constructor({
-    {
+    colour,
-      colour,
+    position = null,
-      position = null,
+    type = CharacterType.dummy,
-      type = CharacterType.dummy,
+    isEatable = type === CharacterType.pacMan,
-      isEatable = type === CharacterType.pacMan,
+    spawnPosition = null,
-      spawnPosition = null
+  }: CharacterProps) {
-    }: CharacterProps) {
+    this.colour = colour
-    this.colour = colour;
+    this.isEatable = isEatable
-    this.isEatable = isEatable;
+    this.spawnPosition = spawnPosition
-    this.spawnPosition = spawnPosition;
 
     if (position) {
-      this.position = position;
+      this.position = position
     } else {
-      this.position = spawnPosition ? {
+      this.position = spawnPosition
-        end: spawnPosition!.at,
+        ? {
-        direction: spawnPosition!.direction
+            end: spawnPosition!.at,
-      } : 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.end = path.end
-      this.position.direction = path.direction;
+      this.position.direction = path.direction
-      this.position.path = undefined;
+      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;
+    if (!this.spawnPosition) return
-    this.follow({end: this.spawnPosition.at, direction: this.spawnPosition.direction});
+    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({
-  public constructor({colour, position, isEatable = true, spawnPosition, type = CharacterType.pacMan}: CharacterProps) {
+    colour,
-    super({colour: colour, position: position, isEatable: isEatable, spawnPosition: spawnPosition, type: type});
+    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) {
-  public constructor({colour, position, isEatable, spawnPosition, type = CharacterType.ghost}: CharacterProps) {
+    super({
-    super({colour: colour, position: position, isEatable: isEatable, spawnPosition: spawnPosition, type: type});
+      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,
       position: position,
       isEatable: false,
-      spawnPosition: {at: {x: 0, y: 0}, direction: Direction.up},
+      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,8 +2,7 @@ export enum Direction {
   left,
   up,
   right,
-  down
+  down,
 }
 
-export const getDirections = () => Object.values(Direction)
+export const getDirections = () => Object.values(Direction).filter(d => !isNaN(Number(d))) as 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 { CharacterType } from "./character"
-import {Direction} from "./direction";
+import { Direction } from "./direction"
 
 /**
  * 0 = empty
@@ -25,29 +25,32 @@ 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 }[] {
+export function getCharacterSpawns(map: GameMap): { type: CharacterType; position: DirectionalPosition }[] {
-
+  const result: { 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[] {
   return getCharacterSpawns(map)
     .filter(s => s.type === CharacterType.pacMan)
     .map(s => s.position)
-}
+}

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

@@ -1,54 +1,62 @@
-import {Character, CharacterType} from "./character";
+import { Character, CharacterType } from "./character"
-import Box from "./box";
+import Box from "./box"
-import {getDefaultStore} from "jotai";
+import { getDefaultStore } from "jotai"
-import {currentPlayerNameAtom, playersAtom} from "../utils/state";
+import { currentPlayerNameAtom, playersAtom } from "../utils/state"
-import rules from "./rules";
+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();
+  private static store = getDefaultStore()
-  public readonly username;
+  public readonly username
-  public readonly pacMan;
+  public readonly pacMan
-  public readonly colour;
+  public readonly colour
-  public readonly box;
+  public readonly box
-  public state;
+  public state
 
   constructor(props: PlayerProps) {
-    this.username = props.username;
+    this.username = props.username
-    this.colour = props.colour;
+    this.colour = props.colour
-    this.box = new Box(props.box ?? {colour: props.colour});
+    this.box = new Box(props.box ?? { colour: props.colour })
-    this.pacMan = new Character(props.pacMan ?? {
+    this.pacMan = new Character(
-      colour: props.colour,
+      props.pacMan ?? {
-      type: CharacterType.pacMan
+        colour: props.colour,
-    });
+        type: CharacterType.pacMan,
-    this.state = props.state ?? State.waitingForPlayers;
+      },
+    )
+    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();
+      const removed = other.box.removePellet()
-      if (removed)
+      if (removed) this.box.addPellet()
-        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 { TileType } from "./tileType"
-import {Character} from "./character";
+import { Character } from "./character"
-import {Direction, getDirections} from "./direction";
+import { Direction, getDirections } from "./direction"
 
 /**
  * Finds all the possible positions for the character to move to
@@ -10,10 +10,15 @@ 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[] {
+export default function findPossiblePositions(
-  if (!character.position || !character.spawnPosition) throw new Error("Character has no position or spawn position");
+  board: GameMap,
-  return findPossibleRecursive(board, character.position, steps, character, characters);
+  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
@@ -24,38 +29,40 @@ export default function findPossiblePositions(board: GameMap, character: Charact
  * @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[] {
+function findPossibleRecursive(
-
+  map: GameMap,
-  const paths: Path[] = [];
+  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)
 
-        tryAddToPath(currentPath);
+        steps--
-
-        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
 }
 
 /**
@@ -65,7 +72,7 @@ function findPossibleRecursive(map: GameMap, currentPath: Path, steps: number, c
  * @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
 }
 
 /**
@@ -75,8 +82,12 @@ 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 {
+function ghostHitsPacMan(
-  return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.end));
+  character: Character,
+  currentPath: Path,
+  characters: Character[],
+): Character | undefined | false {
+  return character.isGhost() && characters.find(c => c.isPacMan() && c.isAt(currentPath.end))
 }
 
 /**
@@ -87,7 +98,7 @@ function ghostHitsPacMan(character: Character, currentPath: Path, characters: Ch
  * @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
 }
 
 /**
@@ -96,9 +107,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]
   }
 }
 
@@ -113,39 +124,53 @@ 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, {
+    return findPossibleRecursive(
-      end: getNewPosition(), direction: direction, path: path.path
+      board,
-    }, steps, character, characters);
+      {
+        end: getNewPosition(),
+        direction: direction,
+        path: path.path,
+      },
+      steps,
+      character,
+      characters,
+    )
   }
-  return [];
+  return []
 }
 
 /**
@@ -157,22 +182,26 @@ function tryMove(board: GameMap, path: Path, direction: Direction, steps: number
  * @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[] {
+function addTeleportationTiles(
-  const possiblePositions = findTeleportationTiles(board);
+  board: GameMap,
-  const paths: Path[] = [];
+  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
-      pos.path = currentPath.path;
+      paths.push(...findPossibleRecursive(board, pos, steps, character, characters))
-      paths.push(...findPossibleRecursive(board, pos, steps, character, characters));
     }
   }
-  return paths;
+  return paths
 }
 
 /**
@@ -183,7 +212,7 @@ function addTeleportationTiles(board: GameMap, currentPath: Path, steps: number,
  * @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)
 }
 
 /**
@@ -192,18 +221,17 @@ 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 possiblePositions: Path[] = []
-  const edge = [0, map.length - 1];
+  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, i, e);
+      pushPath(map, possiblePositions, e, i)
-      pushPath(map, possiblePositions, e, i);
     }
   }
 
-  return possiblePositions;
+  return possiblePositions
 }
 
 /**
@@ -215,7 +243,10 @@ 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),
+    })
   }
 }
 
@@ -226,17 +257,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
 }
 
 /**
@@ -245,8 +276,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;
+  const pos = currentPos.end
-  return pos.x < 0 || pos.x >= boardSize || pos.y < 0 || pos.y >= boardSize;
+  return pos.x < 0 || pos.x >= boardSize || pos.y < 0 || pos.y >= boardSize
 }
 
 /**
@@ -255,8 +286,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;
+  const pos = currentPos.end
-  return board[pos.y][pos.x] === TileType.wall; // Shouldn't work, but it does
+  return board[pos.y][pos.x] === TileType.wall // Shouldn't work, but it does
 }
 
 /**
@@ -265,8 +296,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;
+  const pos = currentPos.end
-  return board[pos.y][pos.x] === TileType.pacmanSpawn || board[pos.y][pos.x] === TileType.ghostSpawn;
+  return board[pos.y][pos.x] === TileType.pacmanSpawn || board[pos.y][pos.x] === TileType.ghostSpawn
 }
 
 /**
@@ -275,8 +306,7 @@ function isSpawn(board: GameMap, currentPos: Path) {
  * @param character The current character
  */
 function isOwnSpawn(currentPos: Path, character: Character): boolean {
-  const pos = currentPos.end;
+  const pos = currentPos.end
-  const charPos = character.spawnPosition!.at;
+  const charPos = character.spawnPosition!.at
-  return charPos.x === pos.x && charPos.y === pos.y;
+  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/game/tileType.ts

@@ -5,4 +5,4 @@ export enum TileType {
   powerPellet,
   ghostSpawn,
   pacmanSpawn,
-}
+}

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 [value, setValue] = useState(defaultValue)
-  const toggleValue = (newValue?: boolean) => newValue ? setValue(newValue) : setValue(!value);
+  const toggleValue = (newValue?: boolean) => (newValue ? setValue(newValue) : setValue(!value))
-  return [value, toggleValue];
+  return [value, toggleValue]
-}
+}

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

@@ -3,35 +3,37 @@
 @tailwind utilities;
 
 .debug {
-    @apply border border-red-500;
+  @apply border border-red-500;
-    @apply after:content-['debug'] after:absolute;
+  @apply after:content-['debug'] after:absolute;
 }
 
 .flex-center {
-    @apply flex justify-center items-center;
+  @apply flex justify-center items-center;
 }
 
 .inline-flex-center {
-    @apply inline-flex justify-center items-center;
+  @apply inline-flex justify-center items-center;
 }
 
 .wh-full {
-    @apply w-full h-full;
+  @apply w-full h-full;
 }
 
 h1 {
-    @apply text-4xl;
+  @apply text-4xl;
 }
 
 h2 {
-    @apply text-3xl;
+  @apply text-3xl;
 }
 
 br {
-    @apply my-2;
+  @apply my-2;
 }
 
-.button-default, button[type=submit], input[type=submit] {
+.button-default,
-    @apply bg-blue-500 hover:bg-blue-600 text-white font-bold py-2 px-4 rounded;
+button[type="submit"],
-    @apply disabled:bg-gray-500;
+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,25 +1,26 @@
-import React from 'react';
+import React from "react"
-import {createRoot} from 'react-dom/client';
+import { createRoot } from "react-dom/client"
-import {BrowserRouter} from 'react-router-dom';
+import { BrowserRouter } from "react-router-dom"
-import {App} from './App';
+import { App } from "./App"
 // @ts-ignore
-import reportWebVitals from './reportWebVitals';
+import reportWebVitals from "./reportWebVitals"
-import {DevTools} from "jotai-devtools";
+import { DevTools } from "jotai-devtools"
-import DebugMenu from "./components/debugMenu";
+import DebugMenu from "./components/debugMenu"
 
-const baseUrl = document.getElementsByTagName('base')[0].getAttribute('href');
+const baseUrl = document.getElementsByTagName("base")[0].getAttribute("href")
-const rootElement = document.getElementById('root');
+const rootElement = document.getElementById("root")
-if (rootElement === null) throw new Error("Root element is null");
+if (rootElement === null) throw new Error("Root element is null")
-const root = createRoot(rootElement);
+const root = createRoot(rootElement)
 
 root.render(
   <BrowserRouter basename={baseUrl ?? undefined}>
-    <DevTools/>
+    <DevTools />
-    <DebugMenu/>
+    <DebugMenu />
-    <App/>
+    <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,29 +1,27 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import WebSocketService from "../websockets/WebSocketService";
+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)
 
-  const [currentCount, setCurrentCount] = React.useState(0);
+  function incrementCounterAndSend() {
-
-  async function incrementCounterAndSend() {
     if (ws.isOpen()) {
-      await ws.send((currentCount + 1).toString());
+      ws.send((currentCount + 1).toString())
     }
   }
 
   function receiveMessage(data: MessageEvent<string>) {
-    const count = parseInt(data.data);
+    const count = parseInt(data.data)
-    if (!isNaN(count))
+    if (!isNaN(count)) setCurrentCount(count)
-      setCurrentCount(count);
   }
 
   React.useEffect(() => {
-    ws.onReceive = receiveMessage;
+    ws.onReceive = receiveMessage
-    ws.open();
+    ws.open()
-    return () => ws.close();
+    return () => ws.close()
-  }, []);
+  }, [])
 
   return (
     <div>
@@ -31,9 +29,13 @@ 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,17 +1,16 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import {GameComponent} from "../components/gameComponent";
+import { GameComponent } from "../components/gameComponent"
-import {useAtomValue} from "jotai";
+import { useAtomValue } from "jotai"
-import {selectedMapAtom, thisPlayerAtom} from "../utils/state";
+import { selectedMapAtom, thisPlayerAtom } from "../utils/state"
 
 const GamePage: FC = () => {
-  const player = useAtomValue(thisPlayerAtom);
+  const player = useAtomValue(thisPlayerAtom)
-  const map = useAtomValue(selectedMapAtom);
+  const map = useAtomValue(selectedMapAtom)
 
   if (player && map) {
-    return <GameComponent player={player} map={map}/>;
+    return <GameComponent player={player} map={map} />
-  } else {
-    return null;
   }
-};
+  return null
+}
 
-export default GamePage;
+export default GamePage

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

@@ -1,27 +1,35 @@
-import React, {FC} from "react";
+import React, { FC } from "react"
-import {Link} from "react-router-dom";
+import { Link } from "react-router-dom"
-import {useAtomValue} from "jotai";
+import { useAtomValue } from "jotai"
-import {thisPlayerAtom} from "../utils/state";
+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 ?
+        {!player ? (
-          <>Start by {" "}
+          <>
-            <Link to={"/login"} className={"text-blue-600"}>logging in</Link>.
+            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,66 +1,65 @@
-import React, {FC, Suspense} from "react";
+import React, { FC, Suspense } from "react"
-import {atom, useAtomValue} from "jotai";
+import { atom, useAtomValue } from "jotai"
-import {Button} from "../components/button";
+import { Button } from "../components/button"
-import {selectedMapAtom, thisPlayerAtom} from "../utils/state";
+import { selectedMapAtom, thisPlayerAtom } from "../utils/state"
-import {getData, postData} from "../utils/api";
+import { getData, postData } from "../utils/api"
-import {getPacManSpawns} from "../game/map";
+import { getPacManSpawns } from "../game/map"
-import {useNavigate} from "react-router-dom";
+import { useNavigate } from "react-router-dom"
 
 const fetchAtom = atom(async () => {
-  const response = await getData("/game/all");
+  const response = await getData("/game/all")
-  return await response.json() as Game[];
+  return (await response.json()) as Game[]
-});
+})
 
 const LobbyPage: FC = () => {
-
+  const thisPlayer = useAtomValue(thisPlayerAtom)
-  const thisPlayer = useAtomValue(thisPlayerAtom);
+  const navigate = useNavigate()
-  const navigate = useNavigate();
+  const map = useAtomValue(selectedMapAtom)
-  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();
+      const data = await response.text()
-      console.error("Error: ", data);
+      console.error("Error: ", data)
       // TODO display error
     }
-
   }
 
   return (
     <>
       <Button onClick={createGame}>New game</Button>
       <Suspense fallback={"Please wait"}>
-        <GameTable className={"mx-auto"}/>
+        <GameTable className={"mx-auto"} />
       </Suspense>
     </>
-  );
+  )
 }
 
-export default LobbyPage;
+export default LobbyPage
 
-const GameTable: FC<ComponentProps> = ({className}) => {
+const GameTable: FC<ComponentProps> = ({ className }) => {
-
+  const data = useAtomValue(fetchAtom)
-  const data = useAtomValue(fetchAtom);
+  const thisPlayer = useAtomValue(thisPlayerAtom)
-  const thisPlayer = useAtomValue(thisPlayerAtom);
+  const navigate = useNavigate()
-  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
     }
   }
@@ -68,33 +67,34 @@ const GameTable: FC<ComponentProps> = ({className}) => {
   return (
     <table className={`rounded overflow-hidden ${className}`}>
       <thead className={"bg-gray-500 text-white"}>
-      <tr className={"my-5"}>
+        <tr className={"my-5"}>
-        <th className={"p-2"}>Id</th>
+          <th className={"p-2"}>Id</th>
-        <th className={"p-2"}>Count</th>
+          <th className={"p-2"}>Count</th>
-        <th className={"p-2"}>State</th>
+          <th className={"p-2"}>State</th>
-        <th className={"p-2"}>Join</th>
+          <th className={"p-2"}>Join</th>
-      </tr>
+        </tr>
       </thead>
       <tbody>
-      {data?.map(game =>
+        {data?.map(game => (
-        <tr key={game.id} className={"even:bg-gray-200"}>
+          <tr key={game.id} className={"even:bg-gray-200"}>
-          <td className={"p-2"}>{game.id}</td>
+            <td className={"p-2"}>{game.id}</td>
-          <td className={"text-center"}>{game.count}</td>
+            <td className={"text-center"}>{game.count}</td>
-          <td>{game.isGameStarted ? "Closed" : "Open"}</td>
+            <td>{game.isGameStarted ? "Closed" : "Open"}</td>
-          <td className={"p-2"}>
+            <td className={"p-2"}>
-            <Button disabled={game.isGameStarted} onClick={() => joinGame(game.id)}>
+              <Button disabled={game.isGameStarted} onClick={() => joinGame(game.id)}>
-              Join
+                Join
-            </Button>
+              </Button>
-          </td>
+            </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,23 +1,22 @@
-import React, {FC, FormEvent, useState} from "react";
+import React, { FC, FormEvent, useState } from "react"
-import {Button} from "../components/button";
+import { Button } from "../components/button"
-import Input from "../components/input";
+import Input from "../components/input"
-import {useSetAtom} from "jotai";
+import { useSetAtom } from "jotai"
-import {thisPlayerAtom} from "../utils/state";
+import { thisPlayerAtom } from "../utils/state"
-import Player from "../game/player";
+import Player from "../game/player"
-import {useNavigate} from "react-router-dom";
+import { useNavigate } from "react-router-dom"
-import {postData} from "../utils/api";
+import { postData } from "../utils/api"
 
 const LoginPage: FC = () => {
-
+  const setThisPlayer = useSetAtom(thisPlayerAtom)
-  const setThisPlayer = useSetAtom(thisPlayerAtom);
+  const navigate = useNavigate()
-  const navigate = useNavigate();
+  const [error, setError] = useState<string | undefined>()
-  const [error, setError] = useState<string | undefined>();
 
   async function handleLogin(e: FormEvent<HTMLFormElement>): Promise<void> {
-    e.preventDefault();
+    e.preventDefault()
-    const fields = e.currentTarget.querySelectorAll("input");
+    const fields = e.currentTarget.querySelectorAll("input")
 
-    let user: User = {username: "", password: ""};
+    let user: User = { username: "", password: "" }
     for (const field of fields) {
       user = {
         ...user,
@@ -26,36 +25,41 @@ 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;
+      const data = (await response.json()) as PlayerProps
-      setThisPlayer(new Player(data));
+      setThisPlayer(new Player(data))
-      navigate("/lobby");
+      navigate("/lobby")
     } else {
-      const data = await response.text();
+      const data = await response.text()
-      console.error(data);
+      console.error(data)
-      setError(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"}>
       <h1 className={"my-5"}>Login</h1>
       {error && <p className={"text-red-500"}>{error}</p>}
       <label htmlFor={username}>Username:</label>
-      <Input id={username} name={username} placeholder={"Username"} autoComplete={"username"} required/>
+      <Input id={username} name={username} placeholder={"Username"} autoComplete={"username"} required />
       <label htmlFor={password}>Password:</label>
-      <Input id={password} name={password} type={"password"} placeholder={"Password"}
+      <Input
-             autoComplete={"current-password"} required/>
+        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 }) => {
+    import("web-vitals").then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
-      getCLS(onPerfEntry);
+      getCLS(onPerfEntry)
-      getFID(onPerfEntry);
+      getFID(onPerfEntry)
-      getFCP(onPerfEntry);
+      getFCP(onPerfEntry)
-      getLCP(onPerfEntry);
+      getLCP(onPerfEntry)
-      getTTFB(onPerfEntry);
+      getTTFB(onPerfEntry)
-    });
+    })
   }
-};
+}
 
-export default reportWebVitals;
+export default reportWebVitals

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

@@ -1,25 +1,27 @@
-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,
+  className?: string
-  style?: React.CSSProperties,
+  style?: React.CSSProperties
-  id?: string,
+  id?: string
-  title?: string,
+  title?: string
 }
 
 interface ChildProps extends ComponentProps {
-  children?: React.JSX.Element | string,
+  children?: React.JSX.Element | string
 }
 
 interface LinkProps extends ChildProps {
-  to: string,
+  to: string
-  newTab?: boolean,
+  newTab?: boolean
 }
 
 interface ButtonProps extends ChildProps {
-  onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void,
+  onClick?: (event: React.MouseEvent<HTMLButtonElement, MouseEvent>) => void
-  disabled?: boolean,
+  disabled?: boolean
-  type?: "button" | "submit" | "reset",
+  type?: "button" | "submit" | "reset"
 }
 
 interface InputProps extends ComponentProps {
@@ -31,23 +33,23 @@ interface InputProps extends ComponentProps {
 }
 
 interface CharacterProps {
-  colour: import("../game/colour").Colour,
+  colour: import("../game/colour").Colour
-  position?: Path | null,
+  position?: Path | null
-  isEatable?: boolean,
+  isEatable?: boolean
-  spawnPosition?: DirectionalPosition | null,
+  spawnPosition?: DirectionalPosition | null
-  type?: import("../game/character").CharacterType,
+  type?: import("../game/character").CharacterType
 }
 
 interface BoxProps {
-  pellets?: number,
+  pellets?: number
-  powerPellets?: number,
+  powerPellets?: number
-  readonly colour: import("../game/colour").Colour,
+  readonly colour: import("../game/colour").Colour
 }
 
 interface PlayerProps {
-  readonly username: string,
+  readonly username: string
-  readonly pacMan?: CharacterProps,
+  readonly pacMan?: CharacterProps
-  readonly colour: import("../game/colour").Colour,
+  readonly colour: import("../game/colour").Colour
-  readonly box?: BoxProps,
+  readonly box?: BoxProps
-  state?: import("../game/player").State,
+  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 id: string
-  readonly count: number,
+  readonly count: number
-  readonly isGameStarted: boolean,
+  readonly isGameStarted: boolean
 }
 
 type User = {
-  readonly username: string,
+  readonly username: string
-  readonly password: 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 username: string
-  readonly gameId: GUID,
+  readonly gameId: GUID
 }
 
 type CreateGameData = {
-  readonly player: PlayerProps,
+  readonly player: PlayerProps
-  readonly spawns: DirectionalPosition[],
+  readonly spawns: DirectionalPosition[]
 }

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

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

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

@@ -1,12 +1,28 @@
-export const getData: Api = async (path, {headers} = {}) => {
+/**
-  if (import.meta.env.MODE === "test") return Promise.resolve(new Response(JSON.stringify([])));
+ * 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([])))
   return await fetch(import.meta.env.VITE_API_HTTP + path, {
     method: "GET",
-    headers: headers
+    headers: headers,
-  });
+  })
 }
 
-export const postData: Api = async (path, {body, 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",
     headers: {

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

@@ -1,74 +1,75 @@
-import Player from "../game/player";
+import Player from "../game/player"
-import {atom} from "jotai";
+import { atom } from "jotai"
-import {Ghost} from "../game/character";
+import { Ghost } from "../game/character"
-import {customMap} from "../game/map";
+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 => {
+export const thisPlayerAtom = atom(
-  const atomValue = get(playerAtom);
+  get => {
-  if (!atomValue) {
+    const atomValue = get(playerAtom)
-    const item = sessionStorage.getItem(playerStorage);
+    if (!atomValue) {
-    if (item) {
+      const item = sessionStorage.getItem(playerStorage)
-      const playerProps = JSON.parse(item) as PlayerProps;
+      if (item) {
-      return new Player(playerProps);
+        const playerProps = JSON.parse(item) as PlayerProps
+        return new Player(playerProps)
+      }
     }
-  }
+    return atomValue
-  return atomValue;
+  },
-}, (_get, set, player: Player | undefined) => {
+  (_get, set, player: Player | undefined) => {
-  if (player)
+    if (player) sessionStorage.setItem(playerStorage, JSON.stringify(player))
-    sessionStorage.setItem(playerStorage, JSON.stringify(player));
+    else sessionStorage.removeItem(playerStorage)
-  else
+    set(playerAtom, player)
-    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);
+  const currentPlayerName = get(currentPlayerNameAtom)
-  return get(playersAtom).find(player => player.username === currentPlayerName);
+  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();
+        return resolve()
       }
-      setTimeout(f, timeout);
+      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_URI: string
-  readonly VITE_API_HTTP: string,
+  readonly VITE_API_HTTP: string
-  readonly VITE_API_WS: 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,
+  onOpen?: VoidFunction
-  onReceive?: MessageEventFunction,
+  onReceive?: MessageEventFunction
-  onClose?: VoidFunction,
+  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 ws?: WebSocket
-  private readonly _url: string;
+  private readonly _url: string
 
-  constructor(url: string, {onOpen, onReceive, onClose, onError}: IWebSocket = {}) {
+  constructor(url: string, { onOpen, onReceive, onClose, onError }: IWebSocket = {}) {
-    this._url = url;
+    this._url = url
-    this._onOpen = onOpen;
+    this._onOpen = onOpen
-    this._onReceive = onReceive;
+    this._onReceive = onReceive
-    this._onClose = onClose;
+    this._onClose = onClose
-    this._onError = onError;
+    this._onError = onError
   }
 
-  private _onOpen?: VoidFunction;
+  private _onOpen?: VoidFunction
 
   set onOpen(onOpen: VoidFunction) {
-    this._onOpen = onOpen;
+    this._onOpen = onOpen
-    if (!this.ws) return;
+    if (!this.ws) return
-    this.ws.onopen = onOpen;
+    this.ws.onopen = onOpen
   }
 
-  private _onReceive?: MessageEventFunction;
+  private _onReceive?: MessageEventFunction
 
   set onReceive(onReceive: MessageEventFunction) {
-    this._onReceive = onReceive;
+    this._onReceive = onReceive
-    if (!this.ws) return;
+    if (!this.ws) return
-    this.ws.onmessage = onReceive;
+    this.ws.onmessage = onReceive
   }
 
-  private _onClose?: VoidFunction;
+  private _onClose?: VoidFunction
 
   set onClose(onClose: VoidFunction) {
-    this._onClose = onClose;
+    this._onClose = onClose
-    if (!this.ws) return;
+    if (!this.ws) return
-    this.ws.onclose = onClose;
+    this.ws.onclose = onClose
   }
 
-  private _onError?: VoidFunction;
+  private _onError?: VoidFunction
 
   set onError(onError: VoidFunction) {
-    this._onError = onError;
+    this._onError = onError
-    if (!this.ws) return;
+    if (!this.ws) return
-    this.ws.onerror = onError;
+    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;
+    if (typeof WebSocket === "undefined" || this.isConnecting()) return
-    this.ws = new WebSocket(this._url);
+    this.ws = new WebSocket(this._url)
-    if (this._onOpen) this.ws.onopen = this._onOpen;
+    if (this._onOpen) this.ws.onopen = this._onOpen
-    if (this._onReceive) this.ws.onmessage = this._onReceive;
+    if (this._onReceive) this.ws.onmessage = this._onReceive
-    if (this._onClose) this.ws.onclose = this._onClose;
+    if (this._onClose) this.ws.onclose = this._onClose
-    if (this._onError) this.ws.onerror = this._onError;
+    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());
+    await wait(() => this.isOpen())
-    if (this._onOpen) this.onOpen = this._onOpen;
+    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,5 +1,6 @@
 using System.Net.WebSockets;
 using Microsoft.AspNetCore.Mvc;
+using pacMan.DTOs;
 using pacMan.Exceptions;
 using pacMan.GameStuff;
 using pacMan.GameStuff.Items;
@@ -8,37 +9,43 @@ 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 : GenericController
+public class GameController(ILogger<GameController> logger, IGameService webSocketService, IActionService actionService)
+    : GenericController(logger, webSocketService)
 {
-    private readonly IActionService _actionService;
+    [HttpGet("[action]")]
-    private readonly GameService _gameService;
+    public override Task Connect() => base.Connect();
 
-    public GameController(ILogger<GameController> logger, GameService webSocketService, IActionService actionService) :
+    /// <summary>
-        base(logger, webSocketService)
+    ///     Retrieves all games from the WebSocketService.
+    /// </summary>
+    /// <returns>
+    ///     An IEnumerable of Game objects representing all the games.
+    /// </returns>
+    [HttpGet("[action]")]
+    public IEnumerable<Game> All()
     {
-        _gameService = webSocketService;
+        Logger.LogDebug("Returning all games");
-        _actionService = actionService;
+        return webSocketService.Games;
     }
 
-    [HttpGet("connect")]
+    /// <summary>
-    public override async Task Accept() => await base.Accept();
+    ///     Adds a player to a game.
-
+    /// </summary>
-    [HttpGet("all")]
+    /// <param name="gameId">The unique identifier of the game.</param>
-    public IEnumerable<Game> GetAllGames()
+    /// <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?
     {
-        Logger.Log(LogLevel.Debug, "Returning all games");
+        Logger.LogDebug("Joining game {}", gameId);
-        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
         {
-            _gameService.JoinById(gameId, player);
+            webSocketService.JoinById(gameId, player);
             return Ok("Game joined successfully");
         }
         catch (GameNotFoundException e)
@@ -51,65 +58,112 @@ public class GameController : GenericController
         }
     }
 
-    [HttpGet("exists/{gameId:guid}")]
+    /// <summary>
-    public IActionResult GameExists(Guid gameId)
+    ///     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)
     {
-        Logger.Log(LogLevel.Debug, "Checking if game {} exists", gameId);
+        Logger.LogDebug("Checking if game {} exists", gameId);
-        return _gameService.Games.Any(game => game.Id == gameId) ? Ok() : NotFound();
+        return webSocketService.Games.Any(game => game.Id == gameId) ? Ok() : NotFound();
     }
 
-    [HttpPost("create")]
+    /// <summary>
-    public IActionResult CreateGame([FromBody] CreateGameData data)
+    ///     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)
     {
-        Logger.Log(LogLevel.Debug, "Creating game");
+        Logger.LogDebug("Creating game");
         try
         {
-            var game = _gameService.CreateAndJoin(data.Player, data.Spawns);
+            var game = webSocketService.CreateAndJoin(data.Player, data.Spawns);
             return Created($"/{game.Id}", game);
         }
         catch (Exception e)
         {
-            return BadRequest(e.Message); // TODO not necessary?
+            return BadRequest(e.Message);
         }
     }
 
     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.Log(LogLevel.Information, "Received: {}", stringResult);
+        Logger.LogInformation("Received: {}", stringResult);
         var action = ActionMessage.FromJson(stringResult);
 
         try
         {
-            _actionService.DoAction(action);
+            DoAction(action);
         }
         catch (Exception e)
         {
-            Logger.Log(LogLevel.Error, "{}", e.Message);
+            Logger.LogError("{}", e.Message);
             action = new ActionMessage { Action = GameAction.Error, Data = e.Message };
         }
 
         return action.ToArraySegment();
     }
 
-    protected override async void Send(ArraySegment<byte> segment)
+    /// <summary>
+    ///     Sends the specified data segment.
+    /// </summary>
+    /// <param name="segment">The data segment to send.</param>
+    protected override void Send(ArraySegment<byte> segment)
     {
-        if (_actionService.Game is not null)
+        if (actionService.Game is not null)
-            _actionService.SendToAll(segment);
+            actionService.SendToAll(segment);
         else if (WebSocket is not null)
-            await _gameService.Send(WebSocket, segment);
+            webSocketService.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);
+    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
+        };
 }

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

@@ -1,29 +1,42 @@
 using System.Net.WebSockets;
 using Microsoft.AspNetCore.Mvc;
-using pacMan.Interfaces;
+using pacMan.Services;
 
 namespace pacMan.Controllers;
 
-public abstract class GenericController : ControllerBase
+/// <summary>
+///     Represents a generic controller for handling WebSocket connections.
+/// </summary>
+public abstract class GenericController(ILogger<GenericController> logger, IWebSocketService webSocketService)
+    : ControllerBase
 {
+    /// <summary>
+    ///     Buffer size used for processing data.
+    /// </summary>
     private const int BufferSize = 1024 * 4;
-    private readonly IWebSocketService _webSocketService;
+
-    protected readonly ILogger<GenericController> Logger;
+    protected readonly ILogger<GenericController> Logger = logger;
     protected WebSocket? WebSocket;
 
-    protected GenericController(ILogger<GenericController> logger, IWebSocketService webSocketService)
+    /// <summary>
-    {
+    ///     Establishes a WebSocket connection with the client.
-        Logger = logger;
+    /// </summary>
-        _webSocketService = webSocketService;
+    /// <remarks>
-        Logger.Log(LogLevel.Debug, "WebSocket Controller created");
+    ///     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.
-    public virtual async Task Accept()
+    ///     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()
     {
         if (HttpContext.WebSockets.IsWebSocketRequest)
         {
             using var webSocket = await HttpContext.WebSockets.AcceptWebSocketAsync();
-            Logger.Log(LogLevel.Information, "WebSocket connection established to {}", HttpContext.Connection.Id);
+            Logger.LogInformation("WebSocket connection established to {}", HttpContext.Connection.Id);
             WebSocket = webSocket;
             await Echo();
         }
@@ -33,16 +46,21 @@ public abstract class GenericController : ControllerBase
         }
     }
 
+    /// <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 == null) return;
+        if (WebSocket is 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;
 
@@ -50,23 +68,27 @@ public abstract class GenericController : ControllerBase
 
                 Send(segment);
             } while (true);
-
             var disconnectSegment = Disconnect();
-            if (disconnectSegment != null) 
+            if (disconnectSegment is not 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.Log(LogLevel.Error, "{}", e.Message);
+            Logger.LogError("{}", e.Message);
         }
     }
 
-    protected virtual async void Send(ArraySegment<byte> segment)
+    /// <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)
     {
-        if (WebSocket == null) return;
+        if (WebSocket is null) return;
-        await _webSocketService.Send(WebSocket, segment);
+        webSocketService.Send(WebSocket, segment);
     }
 
     protected abstract ArraySegment<byte> Run(WebSocketReceiveResult result, byte[] data);

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

@@ -6,21 +6,22 @@ using pacMan.GameStuff.Items;
 namespace pacMan.Controllers;
 
 [ApiController]
-[Route("api/[controller]")]
+[Route("api/[controller]/[action]")]
-public class PlayerController : ControllerBase
+public class PlayerController(UserService userService) : ControllerBase
 {
-    private readonly UserService _userService;
+    /// <summary>
-
+    ///     Logs in a user.
-    public PlayerController(UserService userService) => _userService = userService;
+    /// </summary>
-
+    /// <param name="user">The user object containing the username and password.</param>
-    [HttpPost("login")]
+    /// <returns>Returns an IActionResult indicating the login result.</returns>
+    [HttpPost]
     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("register")]
+    [HttpPost]
-    public async Task<IActionResult> Register([FromBody] User user) => throw new NotSupportedException();
+    public Task<IActionResult> Register([FromBody] User user) => throw new NotSupportedException();
 }

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

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

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

@@ -0,0 +1,40 @@
+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:7.0 AS base
+FROM mcr.microsoft.com/dotnet/aspnet:8.0 AS base
 WORKDIR /app
 EXPOSE 80
 EXPOSE 443
 
-FROM mcr.microsoft.com/dotnet/sdk:7.0 AS build
+FROM mcr.microsoft.com/dotnet/sdk:8.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

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

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

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

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

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

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

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

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

@@ -3,6 +3,9 @@ using System.Text.Json.Serialization;
 
 namespace pacMan.GameStuff;
 
+/// <summary>
+///     Represents various actions that can be performed in a game.
+/// </summary>
 public enum GameAction
 {
     Error,
@@ -14,13 +17,23 @@ 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,6 +8,7 @@ public class Character : IEquatable<Character>
 
     [JsonPropertyName("position")] public MovePath? Position { get; set; }
 
+    // TODO isEdible
     [JsonInclude]
     [JsonPropertyName("isEatable")]
     public bool IsEatable { get; set; } = true;
@@ -31,9 +32,12 @@ public class Character : IEquatable<Character>
         return obj.GetType() == GetType() && Equals((Character)obj);
     }
 
-    public override int GetHashCode() => HashCode.Combine(Colour, Position, IsEatable, SpawnPosition, (int?)Type);
+    public override int GetHashCode() => HashCode.Combine(Colour, Type);
 }
 
+/// <summary>
+///     Represents the types of characters in a game.
+/// </summary>
 public enum CharacterType
 {
     PacMan,

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

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

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

@@ -6,7 +6,14 @@ public class Dice
 {
     private readonly Random _random = new();
 
-    [JsonInclude] public int Value { get; private set; }
+    /// <summary>
+    ///     Represents the value of the previous roll.
+    /// </summary>
+    [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,18 +2,24 @@ 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;
+    private readonly List<Dice> _dices = [new Dice(), new Dice()];
 
-    public DiceCup() =>
+    /// <summary>
-        _dices = new List<Dice>
+    ///     Gets a list of integer values representing the values of the dices.
-        {
+    /// </summary>
-            new(),
+    /// <value>
-            new()
+    ///     A list of integer values representing the values of the dices.
-        };
+    /// </value>
-
+    [JsonInclude]
-    [JsonInclude] public List<int> Values => _dices.Select(dice => dice.Value).ToList();
+    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,6 +3,9 @@ using DAL.Database.Models;
 
 namespace pacMan.GameStuff.Items;
 
+/// <summary>
+///     Represents the various states of a 'Player'.
+/// </summary>
 public enum State
 {
     WaitingForPlayers,
@@ -11,6 +14,9 @@ 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,6 +2,9 @@ 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]
@@ -19,6 +22,11 @@ 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()
         {
@@ -33,9 +41,12 @@ public class MovePath : IEquatable<MovePath>
         return obj.GetType() == GetType() && Equals((MovePath)obj);
     }
 
-    public override int GetHashCode() => HashCode.Combine(Path, End, (int)Direction);
+    public override int GetHashCode() => HashCode.Combine(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; }
@@ -59,6 +70,9 @@ 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,
@@ -67,6 +81,9 @@ 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; }
@@ -80,6 +97,11 @@ 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,6 +1,9 @@
 namespace pacMan.GameStuff;
 
-public class Rules
+/// <summary>
+///     The Rules class holds constant values related to the game rules.
+/// </summary>
+public static class Rules
 {
     public const int MinPlayers = 2;
     public const int MaxPlayers = 4;

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

@@ -1,10 +0,0 @@
-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,5 +1,4 @@
 using DAL.Database.Service;
-using pacMan.Interfaces;
 using pacMan.Services;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -8,6 +7,7 @@ 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,8 +1,7 @@
 using System.Net.WebSockets;
 using System.Text.Json;
-using System.Text.Json.Serialization;
+using pacMan.DTOs;
 using pacMan.Exceptions;
-using pacMan.GameStuff;
 using pacMan.GameStuff.Items;
 
 namespace pacMan.Services;
@@ -11,11 +10,10 @@ 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);
-    object? HandleMoveCharacter(JsonElement? jsonElement);
+    MovePlayerData HandleMoveCharacter(JsonElement? jsonElement);
     ReadyData Ready();
     string FindNextPlayer();
     List<Player> LeaveGame();
@@ -23,68 +21,65 @@ public interface IActionService
     List<Player>? Disconnect();
 }
 
-public class ActionService : IActionService
+/// <summary>
+///     Provides various actions that can be performed in a game
+/// </summary>
+public class ActionService(ILogger<ActionService> logger, IGameService gameService) : IActionService
 {
-    private readonly GameService _gameService;
+    public WebSocket WebSocket { private get; set; } = null!;
-    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; }
 
-    public void DoAction(ActionMessage message)
+    /// <summary>
-    {
+    ///     Rolls the dice and returns the result. If the game is null, an empty list is returned.
-        message.Data = message.Action switch
+    /// </summary>
-        {
+    /// <returns>A list of integers representing the values rolled on the dice.</returns>
-            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 ?? new List<int>();
+        var rolls = Game?.DiceCup.Values ?? [];
-        _logger.Log(LogLevel.Information, "Rolled [{}]", string.Join(", ", rolls));
+        logger.LogInformation("Rolled [{}]", string.Join(", ", rolls));
 
         return rolls;
     }
 
-    public object? HandleMoveCharacter(JsonElement? jsonElement)
+    /// <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)
     {
-        if (Game != null && jsonElement.HasValue)
+        var data = jsonElement?.Deserialize<MovePlayerData>() ?? throw new NullReferenceException("Data is null");
+        if (Game is not null)
         {
-            Game.Ghosts = jsonElement.Value.GetProperty("ghosts").Deserialize<List<Character>>() ??
+            Game.Ghosts = data.Ghosts;
-                          throw new NullReferenceException("Ghosts is null");
+            Game.Players = data.Players;
-            Game.Players = jsonElement.Value.GetProperty("players").Deserialize<List<Player>>() ??
-                           throw new NullReferenceException("Players is null");
         }
 
-        return jsonElement;
+        return data;
     }
 
+    /// <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 data = jsonElement?.Deserialize<JoinGameData>() ?? throw new NullReferenceException("Data is null");
+        var (username, gameId) =
+            jsonElement?.Deserialize<JoinGameData>() ?? throw new NullReferenceException("Data is null");
 
-        var game = _gameService.Games.FirstOrDefault(game => game.Id == data.GameId) ??
+        var game = gameService.FindGameById(gameId) ??
-                   throw new GameNotFoundException($"Game was not found, id \"{data.GameId}\" does not exist");
+                   throw new GameNotFoundException($"Game was not found, id \"{gameId}\" does not exist");
 
-        var player = game.Players.Find(p => p.Username == data.Username)
+        var player = game.FindPlayerByUsername(username) ??
-                     ?? throw new PlayerNotFoundException($"Player \"{data.Username}\" was not found in game");
+                     throw new PlayerNotFoundException($"Player \"{username}\" was not found in game");
 
         player.State = game.IsGameStarted ? State.InGame : State.WaitingForPlayers; // TODO doesn't work anymore
         Player = player;
@@ -94,10 +89,18 @@ public class ActionService : IActionService
         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 == null || Game == null)
+        if (Player is 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
@@ -107,61 +110,55 @@ public class ActionService : IActionService
         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 == null || Player == null) throw new NullReferenceException("Game or Player is null");
+        if (Game is null) throw new NullReferenceException("Game is null");
+        if (Player is null) throw new NullReferenceException("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 == null) return null;
+        if (Player is null) return null;
         Player.State = State.Disconnected;
-        if (Game != null) Game.Connections -= SendSegment;
+        if (Game is not 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);
 
-    private async Task SendSegment(ArraySegment<byte> segment)
+    /// <summary>
-    {
+    ///     Sends an array segment of bytes through the WebSocket connection.
-        if (WebSocket != null) await _gameService.Send(WebSocket, segment);
+    /// </summary>
-        else await Task.FromCanceled(new CancellationToken(true));
+    /// <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);
-
-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,20 +5,26 @@ using pacMan.GameStuff.Items;
 
 namespace pacMan.Services;
 
-public class Game
+/// <summary>
+///     Represents a game instance.
+/// </summary>
+public class Game(Queue<DirectionalPosition> spawns)
 {
     private readonly Random _random = new();
     private int _currentPlayerIndex;
-    private List<Player> _players = new();
+    private List<Player> _players = [];
-
-    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)
@@ -34,17 +40,36 @@ public class Game
         }
     }
 
-    [JsonIgnore] public List<Character> Ghosts { get; set; } = new(); // TODO include
+    [JsonIgnore] public List<Character> Ghosts { get; set; } = []; // TODO include
 
-    [JsonIgnore] private Queue<DirectionalPosition> Spawns { get; }
+    /// <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] 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?
-    [JsonInclude] public bool IsGameStarted => Count > 0 && Players.Any(player => player.State is State.InGame);
+    /// <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);
 
+    /// <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
@@ -53,7 +78,7 @@ public class Game
         }
         catch (DivideByZeroException)
         {
-            throw new InvalidOperationException("There are no players in the game.");
+            throw new PlayerNotFoundException("There are no players in the game.");
         }
 
         return Players[_currentPlayerIndex];
@@ -61,8 +86,22 @@ public class Game
 
     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)
@@ -86,6 +125,10 @@ public class Game
         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;
@@ -94,8 +137,17 @@ public class Game
         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);
@@ -105,11 +157,25 @@ public class Game
         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 != State.Ready)) return false;
+        if (Players.Any(player => player.State is not 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,20 +4,27 @@ 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 : WebSocketService
+public class GameService(ILogger<WebSocketService> logger) : WebSocketService(logger), IGameService
 {
-    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; } = new();
+    public SynchronizedCollection<Game> Games { get; } = [];
 
     /// <summary>
     ///     This method tries to find a game with the specified id, add a player to it and return the updated game.
@@ -57,8 +64,20 @@ public class GameService : WebSocketService
         return game;
     }
 
-    public Game? FindGameByUsername(string username)
+    /// <summary>
-    {
+    ///     Finds a game by its ID.
-        return Games.FirstOrDefault(game => game.Players.Exists(player => player.Username == username));
+    /// </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));
 }

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

@@ -1,20 +1,33 @@
 using System.Net.WebSockets;
-using pacMan.Interfaces;
 using pacMan.Utils;
 
 namespace pacMan.Services;
 
-
+public interface IWebSocketService
-public class WebSocketService : IWebSocketService
 {
-    protected readonly ILogger<WebSocketService> Logger;
+    Task Send(WebSocket webSocket, ArraySegment<byte> segment);
-
+    Task<WebSocketReceiveResult> Receive(WebSocket webSocket, byte[] buffer);
-    public WebSocketService(ILogger<WebSocketService> logger)
+    Task Close(WebSocket webSocket, WebSocketCloseStatus closeStatus, string? closeStatusDescription);
-    {
+}
-        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(
@@ -23,18 +36,34 @@ public class WebSocketService : IWebSocketService
             true,
             CancellationToken.None);
 
-        Logger.Log(LogLevel.Debug, "Message sent to WebSocket");
+        logger.LogDebug("Message sent through 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.Log(LogLevel.Debug,
+        logger.LogDebug(
             "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(
@@ -42,6 +71,6 @@ public class WebSocketService : IWebSocketService
             closeStatusDescription,
             CancellationToken.None);
 
-        Logger.Log(LogLevel.Information, "WebSocket connection closed");
+        logger.LogInformation("WebSocket connection closed");
     }
 }

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

@@ -6,13 +6,24 @@ 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, "");
+        return InvalidCharacters().Replace(s, string.Empty);
     }
 
+    /// <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);
@@ -20,6 +31,10 @@ 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>net7.0</TargetFramework>
+        <TargetFramework>net9.0</TargetFramework>
         <Nullable>enable</Nullable>
         <TypeScriptCompileBlocked>true</TypeScriptCompileBlocked>
         <TypeScriptToolsVersion>Latest</TypeScriptToolsVersion>
@@ -13,70 +13,71 @@
         <RootNamespace>pacMan</RootNamespace>
         <ImplicitUsings>enable</ImplicitUsings>
         <DockerDefaultTargetOS>Linux</DockerDefaultTargetOS>
+        <LangVersion>13</LangVersion>
     </PropertyGroup>
 
     <ItemGroup>
-        <PackageReference Include="Microsoft.AspNetCore.SpaProxy" Version="7.0.10" />
+        <PackageReference Include="Microsoft.AspNetCore.SpaProxy" Version="8.0.0"/>
-        <PackageReference Include="Microsoft.TypeScript.MSBuild" Version="5.2.2">
+        <PackageReference Include="Microsoft.TypeScript.MSBuild" Version="5.3.3">
-          <PrivateAssets>all</PrivateAssets>
+            <PrivateAssets>all</PrivateAssets>
-          <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+            <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
         </PackageReference>
-        <PackageReference Include="System.ServiceModel.Primitives" Version="6.1.0" />
+        <PackageReference Include="System.ServiceModel.Primitives" Version="8.0.0" />
     </ItemGroup>
 
     <ItemGroup>
         <!-- Don't publish the SPA source files, but do show them in the project files list -->
-        <Content Remove="$(SpaRoot)**" />
+        <Content Remove="$(SpaRoot)**"/>
         <Content Include="..\.dockerignore">
-          <Link>.dockerignore</Link>
+            <Link>.dockerignore</Link>
         </Content>
-        <None Remove="$(SpaRoot)**" />
+        <None Remove="$(SpaRoot)**"/>
-        <None Include="$(SpaRoot)**" Exclude="$(SpaRoot)node_modules\**" />
+        <None Include="$(SpaRoot)**" Exclude="$(SpaRoot)node_modules\**"/>
     </ItemGroup>
 
     <ItemGroup>
-      <TypeScriptCompile Remove="ClientApp\src\components\Counter.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\components\Counter.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\components\FetchData.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\components\FetchData.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\components\Home.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\components\Home.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\pages\FetchData.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\pages\FetchData.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\classes\tileMap.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\classes\tileMap.ts"/>
-      <TypeScriptCompile Remove="ClientApp\src\game\tileMap.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\game\tileMap.ts"/>
-      <TypeScriptCompile Remove="ClientApp\src\components\gameCanvas.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\components\gameCanvas.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\game\game.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\game\game.ts"/>
-      <TypeScriptCompile Remove="ClientApp\src\App.test.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\App.test.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\game\playerStats.tsx" />
+        <TypeScriptCompile Remove="ClientApp\src\game\playerStats.tsx"/>
-      <TypeScriptCompile Remove="ClientApp\src\websockets\actions.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\websockets\actions.ts"/>
-      <TypeScriptCompile Remove="ClientApp\src\utils\colours.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\utils\colours.ts"/>
-      <TypeScriptCompile Remove="ClientApp\src\utils\dom.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\utils\dom.ts"/>
-      <TypeScriptCompile Remove="ClientApp\src\game\pellet.ts" />
+        <TypeScriptCompile Remove="ClientApp\src\game\pellet.ts"/>
     </ItemGroup>
 
     <ItemGroup>
-      <Folder Include="ClientApp\tests\utils\" />
+        <Folder Include="ClientApp\tests\utils\"/>
     </ItemGroup>
 
     <ItemGroup>
-      <ProjectReference Include="..\DataAccessLayer\DataAccessLayer.csproj" />
+        <ProjectReference Include="..\DataAccessLayer\DataAccessLayer.csproj"/>
     </ItemGroup>
 
     <Target Name="DebugEnsureNodeEnv" BeforeTargets="Build" Condition=" '$(Configuration)' == 'Debug' And !Exists('$(SpaRoot)node_modules') ">
         <!-- Ensure Node.js is installed -->
         <Exec Command="node --version" ContinueOnError="true">
-            <Output TaskParameter="ExitCode" PropertyName="ErrorCode" />
+            <Output TaskParameter="ExitCode" PropertyName="ErrorCode"/>
         </Exec>
-        <Error Condition="'$(ErrorCode)' != '0'" Text="Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE." />
+        <Error Condition="'$(ErrorCode)' != '0'" Text="Node.js is required to build and run this project. To continue, please install Node.js from https://nodejs.org/, and then restart your command prompt or IDE."/>
-        <Message Importance="high" Text="Restoring dependencies using 'pnpm'. This may take several minutes..." />
+        <Message Importance="high" Text="Restoring dependencies using 'pnpm'. This may take several minutes..."/>
-        <Exec WorkingDirectory="$(SpaRoot)" Command="pnpm install" />
+        <Exec WorkingDirectory="$(SpaRoot)" Command="pnpm install"/>
     </Target>
 
     <Target Name="PublishRunWebpack" AfterTargets="ComputeFilesToPublish">
         <!-- As part of publishing, ensure the JS resources are freshly built in production mode -->
-        <Exec WorkingDirectory="$(SpaRoot)" Command="pnpm install" />
+        <Exec WorkingDirectory="$(SpaRoot)" Command="pnpm install"/>
-        <Exec WorkingDirectory="$(SpaRoot)" Command="pnpm build" />
+        <Exec WorkingDirectory="$(SpaRoot)" Command="pnpm build"/>
 
         <!-- Include the newly-built files in the publish output -->
         <ItemGroup>
-            <DistFiles Include="$(SpaRoot)build\**" />
+            <DistFiles Include="$(SpaRoot)build\**"/>
             <ResolvedFileToPublish Include="@(DistFiles->'%(FullPath)')" Exclude="@(ResolvedFileToPublish)">
                 <RelativePath>wwwroot\%(RecursiveDir)%(FileName)%(Extension)</RelativePath>
                 <CopyToPublishDirectory>PreserveNewest</CopyToPublishDirectory>