Switch players after move, can only roll dice once, and other improvements

BackendTests/Services/ActionServiceTests.cs

@@ -182,4 +182,20 @@ public class ActionServiceTests
     }
 
     #endregion
+
+    #region FindNextPlayer()
+
+    [Test]
+    public void FindNexPlayer_OnePlayer()
+    {
+        Assert.Fail();
+    }
+    
+    [Test]
+    public void FindNexPlayer_TwoPlayers()
+    {
+        Assert.Fail();
+    }
+
+    #endregion
 }

BackendTests/Services/GameGroupTests.cs

@@ -196,4 +196,23 @@ public class GameGroupTests
     }
 
     #endregion
+
+    #region IsGameStarted()
+
+    [Test]
+    public void IsGameStarted_AllWaiting()
+    {
+        AddFullParty();
+        Assert.That(_gameGroup.IsGameStarted, Is.False);
+    }
+    
+    [Test]
+    public void IsGameStarted_AllInGame()
+    {
+        AddFullParty();
+        _gameGroup.Players.ForEach(player => player.State = State.InGame);
+        Assert.That(_gameGroup.IsGameStarted, Is.True);
+    }
+
+    #endregion
 }

BackendTests/Services/WebSocketServiceTests.cs

@@ -153,7 +153,7 @@ public class WebSocketServiceTests
         Assert.Multiple(() =>
         {
             Assert.That(group.Players, Has.Count.EqualTo(1));
-            Assert.That(group.RandomPlayer, Is.EqualTo(player));
+            Assert.That(group.NextPlayer, Is.EqualTo(player));
             Assert.That(_service.Games, Has.Count.EqualTo(1));
         });
     }
@@ -174,7 +174,7 @@ public class WebSocketServiceTests
         Assert.Multiple(() =>
         {
             Assert.That(group.Players, Has.Count.EqualTo(1));
-            Assert.That(group.RandomPlayer, Is.EqualTo(player5));
+            Assert.That(group.NextPlayer, Is.EqualTo(player5));
             Assert.That(_service.Games, Has.Count.EqualTo(2));
             Assert.That(_service.Games.First(), Has.Count.EqualTo(Rules.MaxPlayers));
         });

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

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

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

@@ -6,27 +6,32 @@ import WebSocketService from "../websockets/WebSocketService";
 import {getCharacterSpawns, testMap} from "../game/map";
 import Player from "../game/player";
 import PlayerStats from "../components/playerStats";
-import {getDefaultStore, useAtom, useAtomValue} from "jotai";
+import {getDefaultStore, useAtom, useAtomValue, useSetAtom} from "jotai";
-import {diceAtom, ghostsAtom, playersAtom, selectedDiceAtom} from "../utils/state";
+import {diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom, selectedDiceAtom} from "../utils/state";
 import {CharacterType} from "../game/character";
 import GameButton from "./gameButton";
 
 const wsService = new WebSocketService(import.meta.env.VITE_API);
 
-// TODO do not allow players to roll dice multiple times
+// TODO don't start game until at least 2 players have joined
-// TODO fix tailwind colours from getBgCssColour
+// TODO join game lobby
+// TODO steal from other players
+// TODO show box with collected pellets
+// TODO layout
 
 export const GameComponent: Component<{ player: Player }> = ({player}) => {
   const players = useAtomValue(playersAtom);
 
   const dice = useAtomValue(diceAtom);
   const [selectedDice, setSelectedDice] = useAtom(selectedDiceAtom);
+  const setActiveRollDiceButton = useSetAtom(rollDiceButtonAtom);
 
   function rollDice(): void {
     if (!player.isTurn()) return;
 
     setSelectedDice(undefined);
     wsService.send({Action: GameAction.rollDice});
+    setActiveRollDiceButton(false);
   }
 
   function onCharacterMove(eatenPellets: Position[]): void {
@@ -44,9 +49,13 @@ export const GameComponent: Component<{ player: Player }> = ({player}) => {
       }
     };
     wsService.send(data);
+
+    if (dice?.length === 0) {
+      endTurn();
+    }
   }
 
-  async function sendPlayer(): Promise<void> {
+  function sendPlayer(): void {
     wsService.send({
       Action: GameAction.playerInfo,
       Data: {
@@ -61,11 +70,15 @@ export const GameComponent: Component<{ player: Player }> = ({player}) => {
     wsService.send({Action: GameAction.ready});
   }
 
+  function endTurn() {
+    wsService.send({Action: GameAction.nextPlayer});
+  }
+
   useEffect(() => {
     wsService.onReceive = doAction;
     wsService.open();
 
-    wsService.waitForOpen().then(() => void sendPlayer());
+    wsService.waitForOpen().then(() => sendPlayer());
 
     return () => wsService.close();
   }, []);

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

@@ -1,22 +1,27 @@
 import React from "react";
 import Player, {State} from "../game/player";
+import {useAtomValue} from "jotai";
+import {currentPlayerNameAtom} from "../utils/state";
 
 const PlayerStats: Component<{ player: Player } & ComponentProps> = (
   {
     player,
     className,
     id
-  }) => (
+  }) => {
-  <div key={player.Colour} className={`w-fit m-2 ${className}`} id={id}>
+  const currentPlayerName = useAtomValue(currentPlayerNameAtom);
-    <p className={player.isTurn() ? "underline" : ""}>Player: {player.Name}</p>
+  return (
-    <p>Colour: {player.Colour}</p>
+    <div key={player.Colour} className={`w-fit m-2 ${className}`} id={id}>
-    {player.State === State.inGame ?
+      <p className={player.Name === currentPlayerName ? "underline" : ""}>Player: {player.Name}</p>
-      <>
+      <p>Colour: {player.Colour}</p>
-        <p>Pellets: {player.Box.count}</p>
+      {player.State === State.inGame ?
-        <p>PowerPellets: {player.Box.countPowerPellets}</p>
+        <>
-      </> :
+          <p>Pellets: {player.Box.count}</p>
-      <p>{player.State === State.waitingForPlayers ? "Waiting" : "Ready"}</p>}
+          <p>PowerPellets: {player.Box.countPowerPellets}</p>
-  </div>
+        </> :
-);
+        <p>{player.State === State.waitingForPlayers ? "Waiting" : "Ready"}</p>}
+    </div>
+  );
+};
 
 export default PlayerStats;

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

@@ -2,7 +2,7 @@ import {Character, CharacterType} from "./character";
 import Box from "./box";
 import {Colour} from "./colour";
 import {getDefaultStore} from "jotai";
-import {currentPlayerAtom} from "../utils/state";
+import {currentPlayerNameAtom} from "../utils/state";
 import Pellet from "./pellet";
 
 export enum State {
@@ -31,7 +31,7 @@ export default class Player {
 
   public isTurn(): boolean {
     const store = getDefaultStore();
-    return store.get(currentPlayerAtom)?.Name === this.Name;
+    return store.get(currentPlayerNameAtom) === this.Name;
   }
 
   public addPellet(pellet: Pellet): void {

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

@@ -3,7 +3,7 @@ import {CharacterType, Ghost} from "../game/character";
 import {getCharacterSpawns, testMap} from "../game/map";
 import {TileType} from "../game/tileType";
 import {getDefaultStore} from "jotai";
-import {currentPlayerNameAtom, diceAtom, ghostsAtom, playersAtom} from "./state";
+import {currentPlayerNameAtom, diceAtom, ghostsAtom, playersAtom, rollDiceButtonAtom} from "./state";
 import {Colour} from "../game/colour";
 
 export enum GameAction {
@@ -11,6 +11,7 @@ export enum GameAction {
   moveCharacter,
   playerInfo,
   ready,
+  nextPlayer,
 }
 
 const store = getDefaultStore();
@@ -45,6 +46,9 @@ export const doAction: MessageEventFunction<string> = (event): void => { // TODO
     case GameAction.ready:
       ready(message.Data);
       break;
+    case GameAction.nextPlayer:
+      nextPlayer(message.Data);
+      break;
   }
 };
 
@@ -93,17 +97,21 @@ function playerInfo(data?: PlayerProps[]): void {
   store.set(playersAtom, playerProps.map(p => new Player(p)));
 }
 
-type ReadyData =
+type ReadyData = { AllReady: boolean, Players: PlayerProps[] } | string;
-  | { AllReady: true, Starter: string, Players: PlayerProps[] }
-  | { AllReady: false, Players: PlayerProps[] }
-  | string;
 
 function ready(data?: ReadyData): void {
   if (data && typeof data !== "string") {
     const players = data.Players.map(p => new Player(p));
     store.set(playersAtom, players);
     if (data.AllReady) {
-      store.set(currentPlayerNameAtom, data.Starter);
+      store.set(currentPlayerNameAtom, data.Players[0].Name);
     }
+  } else {
+    console.error("Error:", data);
   }
 }
+
+function nextPlayer(currentPlayerName?: string): void {
+  store.set(currentPlayerNameAtom, currentPlayerName);
+  store.set(rollDiceButtonAtom, true);
+}

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

@@ -49,3 +49,7 @@ export const currentPlayerAtom = atom<Player | undefined>(get => {
   const currentPlayerName = get(currentPlayerNameAtom);
   return get(playersAtom).find(player => player.Name === currentPlayerName);
 });
+/**
+ * Whether the roll dice button should be enabled.
+ */
+export const rollDiceButtonAtom = atom(true);

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

@@ -7,7 +7,8 @@ public enum GameAction
     RollDice,
     MoveCharacter,
     PlayerInfo,
-    Ready
+    Ready,
+    NextPlayer
 }
 
 public class ActionMessage<T>

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

@@ -40,6 +40,7 @@ public class ActionService : IActionService
             GameAction.RollDice => RollDice(),
             GameAction.PlayerInfo => SetPlayerInfo(message),
             GameAction.Ready => Ready(),
+            GameAction.NextPlayer => FindNextPlayer(),
             _ => message.Data
         };
     }
@@ -79,16 +80,11 @@ public class ActionService : IActionService
         if (Player != null && Group != null)
         {
             var players = Group.SetReady(Player).ToArray();
-            if (players.All(p => p.State == State.Ready))
+            // TODO roll to start
-            {
+            Group.Shuffle();
-                // TODO roll to start
+            var allReady = players.All(p => p.State == State.Ready);
-                Group.SetAllInGame();
+            if (allReady) Group.SetAllInGame();
-                data = new { AllReady = true, Players = players, Starter = Group.RandomPlayer.Name };
+            data = new { AllReady = allReady, Players = players };
-            }
-            else
-            {
-                data = new { AllReady = false, Players = players };
-            }
         }
         else
         {
@@ -97,6 +93,8 @@ public class ActionService : IActionService
 
         return data;
     }
+
+    public string FindNextPlayer() => Group?.NextPlayer.Name ?? "Error: No group found";
 }
 
 public class PlayerInfoData

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

@@ -8,25 +8,37 @@ namespace pacMan.Services;
 public class GameGroup : IEnumerable<IPlayer> // TODO handle disconnects and reconnects
 {
     private readonly Random _random = new();
+    private int _currentPlayerIndex;
 
     public GameGroup(Queue<DirectionalPosition> spawns) => Spawns = spawns;
 
     public List<IPlayer> Players { get; } = new();
     private Queue<DirectionalPosition> Spawns { get; }
 
-    public IPlayer RandomPlayer => Players[_random.Next(Count)];
-
     public int Count => Players.Count;
 
+    public IPlayer NextPlayer
+    {
+        get
+        {
+            _currentPlayerIndex = (_currentPlayerIndex + 1) % Count;
+            return Players[_currentPlayerIndex];
+        }
+    }
+
+    public bool IsGameStarted => Count > 0 && Players.All(player => player.State is State.InGame or State.Disconnected);
+
     public IEnumerator<IPlayer> GetEnumerator() => Players.GetEnumerator();
 
     IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
 
+    public void Shuffle() => Players.Sort((_, _) => _random.Next(-1, 2));
+
     public event Func<ArraySegment<byte>, Task>? Connections;
 
-    public bool AddPlayer(IPlayer player) // TODO if name exists, use that player instead
+    public bool AddPlayer(IPlayer player)
     {
-        if (Players.Count >= Rules.MaxPlayers) return false;
+        if (Players.Count >= Rules.MaxPlayers || IsGameStarted) return false;
 
         player.State = State.WaitingForPlayers;
         if (Players.Exists(p => p.Name == player.Name)) return true;