2024-05-25 20:59:37 +00:00
25 changed files with 799 additions and 378 deletions
--- a/Controllers/RoomController.cs
+++ b/Controllers/RoomController.cs
@@ -1,6 +1,5 @@
-using System.Text;
-using System.Text.Json;
-using MauMau_Server.Websockets;
+using System.Text.Json;
+using MauMau_Server.Room;
 using Microsoft.AspNetCore.Mvc;

 namespace MauMau_Server.Controllers;
--- a/Mau/ActionDTO.cs
+++ b/Mau/ActionDTO.cs
@@ -2,12 +2,12 @@

 public class ActionDTO
 {
-    public string Action { get; set; }
+    public string Type { get; set; }
    public string Data { get; set; }

-    public ActionDTO(string action, string data)
+    public ActionDTO(string type, string data)
    {
-        Action = action;
+        Type = type;
        Data = data;
    }

--- a/Mau/Card.cs
+++ b/Mau/Card.cs
@@ -25,6 +25,31 @@ public class Card
    }
 }

+public static class CardExtensions
+{
+    public static bool IsSameCard(this Card card1, Card card2)
+    {
+        return card1.IsSameCardType(card2) && card1.IsSameCardValue(card2);
+    }
+    
+    public static bool IsSameCardType(this Card card1, Card card2)
+    {
+        return card1.CardType == card2.CardType;
+    }
+    
+    public static bool IsSameCardValue(this Card card1, Card card2)
+    {
+        return card1.CardValue == card2.CardValue;
+    }
+    
+    public static bool CanBePlayedOn(this Card playedCard, Card currentCard)
+    {
+        return playedCard.IsSameCardType(currentCard)
+            || playedCard.IsSameCardValue(currentCard)
+            || playedCard.CardType == CardType.JOKER;
+    }
+}
+
 public enum CardType
 {
    SPADES,
--- a/Mau/Deck.cs
+++ b/Mau/Deck.cs
@@ -2,47 +2,93 @@

 public class Deck
 {
-    public List<Card> UnusedDeck = new();
-    public List<Card> UsedDeck = new();
+    private List<Card> _unusedDeck = new();
+    private List<Card> _usedDeck = new();
+    public Card CurrentCard;

+    /**
+     * <summary>
+     * Creates a new deck instance with a new shuffled set of cards
+     * </summary>
+     */
    public Deck()
    {
        CreateSet();
        ShuffleDeck();
+        CurrentCard = DrawCard();
+        _usedDeck.Add(CurrentCard);
+
+        if (CurrentCard.CardType != CardType.JOKER) return;
+        CurrentCard = DrawCard();
+        _usedDeck.Add(CurrentCard);
    }
    
+    /**
+     * <summary>
+     * Adds the given card to the used cards deck.
+     * </summary>
+     * <param name="card">The card to add to the used cards deck.</param>
+     */
+    public void AddCardToUsedDeck(Card card)
+    {
+        _usedDeck.Add(card);
+    }
+
+    /**
+     * <summary>
+     * Adds the given list of cards to the used cards deck.
+     * </summary>
+     * <param name="cards">The list of cards to add to the used cards deck.</param>
+     */
+    public void AddCardsToUsedDeck(IEnumerable<Card> cards)
+    {
+        _usedDeck.AddRange(cards);
+    }
+
+    /**
+     * <summary>
+     * Creates a new deck of cards and adds them to the unused deck.
+     * </summary>
+     */
    private void CreateSet()
    {
        foreach (CardType cardType in Enum.GetValues(typeof(CardType)))
        {
            if (cardType == CardType.JOKER)
            {
-                UnusedDeck.Add(new Card(cardType, CardValue.RED));
-                UnusedDeck.Add(new Card(cardType, CardValue.BLACK));
+                _unusedDeck.Add(new Card(cardType, CardValue.RED));
+                _unusedDeck.Add(new Card(cardType, CardValue.BLACK));
                continue;
            }
            foreach (CardValue cardValue in Enum.GetValues(typeof(CardValue)))
            {
                if (cardValue is CardValue.RED or CardValue.BLACK) continue;
-                UnusedDeck.Add(new Card(cardType, cardValue));
+                _unusedDeck.Add(new Card(cardType, cardValue));
            }
        }
    }
    
-    public List<Card> GetUnusedDeck()
-    {
-        return UnusedDeck;
-    }
-    
+    /**
+     * <summary>
+     * Draws a card from the deck.
+     * If the deck is empty, the deck is reshuffled with <see cref="ReshuffleDeck"/>.
+     * </summary>
+     */
    public Card DrawCard()
    {
-        if (UnusedDeck.Count == 0) ReshuffleDeck();
-        var card = UnusedDeck[0];
-        UnusedDeck.RemoveAt(0);
+        if (_unusedDeck.Count == 0) ReshuffleDeck();
+        var card = _unusedDeck[0];
+        _unusedDeck.RemoveAt(0);
        return card;
    }

-    public List<Card> DrawCards(int amount)
+    /**
+     * <summary>
+     * Take a given amount of cards from the deck. This method calls <see cref="DrawCard"/> for each card.
+     * </summary>
+     * <param name="amount">The amount of cards to draw from the deck.</param>
+     */
+    public IEnumerable<Card> DrawCards(int amount)
    {
        var cards = new List<Card>();
        for (var i = 0; i < amount; i++)
@@ -52,17 +98,18 @@ public class Deck
        return cards;
    }

-    public void AddCardToUsedDeck(Card card)
-    {
-        UsedDeck.Add(card);
-    }
-
+    /**
+     * <summary>
+     * Moves all the used cards back to the unused deck and shuffles it.
+     * If there are no cards to reshuffle, a new set of cards is created and shuffled.
+     * </summary>
+     */
    private void ReshuffleDeck()
    {
-        UnusedDeck.AddRange(UsedDeck);
-        UsedDeck.Clear();
+        _unusedDeck.AddRange(_usedDeck);
+        _usedDeck.Clear();

-        if (UnusedDeck.Count == 0)
+        if (_unusedDeck.Count == 0)
        {
            CreateSet();
        }
@@ -70,8 +117,13 @@ public class Deck
        ShuffleDeck();
    }

+    /**
+     * <summary>
+     * Shuffles all the cards in the deck using the Fisher-Yates algorithm.
+     * </summary>
+     */
    private void ShuffleDeck()
    {
-        UnusedDeck = UnusedDeck.OrderBy(x => Guid.NewGuid()).ToList();
+        _unusedDeck = _unusedDeck.OrderBy(x => Guid.NewGuid()).ToList();
    }
 }
--- a/Mau/Game.cs
+++ b/Mau/Game.cs
@@ -1,94 +1,278 @@
-using System.Text.Json;
+using MauMau_Server.Mau.GameMessages;
+using MauMau_Server.Mau.Managers;
 using MauMau_Server.Websockets;
+using MauMau_Server.Room;
+using MauMau_Server.Room.Messages;
+using Newtonsoft.Json;

 namespace MauMau_Server.Mau;

-public class Game
+public class Game : RoomType
 {
-    public readonly Deck Deck = new();
-    public Card CurrentCard;
-    public List<Player> Players = new();
-    public Player CurrentPlayer;
-    public int TurnDirection = 1;
-    private readonly Room _room;
+    private readonly Deck _deck = new();
+    private readonly TurnManager _turnManager = new();
+    public readonly List<Card> MauCardBuffer = new();
+    public CardType? NextAllowedCardType { get; set; }

-    public Game(Room room)
+    public Game(Room.Room room, IEnumerable<ConnectionInstance> connections) : base(room)
    {
-        _room = room;
-        CurrentCard = Deck.DrawCard();
-        Deck.AddCardToUsedDeck(CurrentCard);
-    }
-
-    public void AddPlayerToGame(ConnectionInstance connection)
-    {
-        var player = new Player(connection)
+        // Convert all the connections to players
+        List<Player> players = new();
+        foreach (var player in connections.Select(connection => new Player(connection)))
        {
-            Hand = Deck.DrawCards(8)
-        };
-        Players.Add(player);
-        if (Players.Count > 1) return;
-        CurrentPlayer = player;
-        CurrentPlayer.State = PlayerState.TURN;
-    }
-    
-    public void RemovePlayer(string playerId)
-    {
-        var player = GetPlayer(playerId);
-        Players.Remove(player);
-    }
-
-    public void HandleAction(string playerId, ActionDTO action)
-    {
-        var player = GetPlayer(playerId);
-        if (CurrentPlayer != player) return;
-        switch (action.Action)
-        {
-            case "PLAYCARD":
-            {
-                if (player.State != PlayerState.TURN)
-                {
-                    break;
-                }
-                var card = JsonSerializer.Deserialize<CardDTO>(action.Data).ToCard();
-                PlayCard(player, card);
-                break;
-            }
-            case "CHOOSE":
-                var choice = action.Data;
-                if (!Enum.TryParse(choice, out CardType cardType))
-                {
-                    break;
-                }
-                CurrentPlayer.State = PlayerState.WAIT;
-                CurrentPlayer = CurrentCard.CardType == CardType.JOKER ? GetNextPlayer(2) : GetNextPlayer();
-                CurrentPlayer.State = PlayerState.TURN;
-                CurrentCard = new Card(cardType, CardValue.JACK);
-                break;
-            case "DRAW":
-                if (player.State != PlayerState.TURN)
-                {
-                    break;
-                }
-                DrawCard(player);
-                break;
+            // Give the new player a hand of cards
+            var initialHand = _deck.DrawCards(8);
+            player.GiveCards(initialHand);
+            players.Add(player);
        }
+
+        // Add all the players to the turn manager
+        _turnManager.Initialize(players);
+        
+        // Broadcast new game state
+        SendGameState();
    }

-    private void PlayCard(Player player, Card card)
+    /**
+     * <inheritdoc cref="RoomType.OnMessage"/>
+     */
+    public override void OnMessage(ConnectionInstance sender, RoomMessage<string> message)
    {
-        var hand = player.Hand;
-        if (!IsCardInHand(hand, card) || !IsCardPlayable(CurrentCard, card)) return;
-        Deck.AddCardToUsedDeck(card);
-        hand.Remove(GetSameCardFromHand(hand, card));
-        CurrentCard = card;
-        if (hand.Count == 0)
+        // If the message type is not a game message, ignore the message
+        if (message.Type is not ("CHOOSE" or "DRAW" or "PLAY"))
        {
-            _room.EndGame(player);
            return;
        }
-        HandleNextPlayer(card);
+        
+        // Get the player that sent the message
+        var player = _turnManager.Players.FirstOrDefault(x => x.IsMe(sender.Id));
+
+        // If the player is not the player that is currently playing, ignore the message
+        if (_turnManager.CurrentPlayer != player) return;
+
+        // Based on the message intent, handle the message
+        switch (message.Type)
+        {
+            case "CHOOSE":
+                Choose(player, message.Data);
+                break;
+            case "PLAY":
+                Play(player, message.Data);
+                break;
+            default:
+                Draw(player);
+                break;
+        }
    }

+    /**
+     * <inheritdoc cref="RoomType.OnConnect"/>
+     */
+    public override void OnConnect(ConnectionInstance connection)
+    {
+        // Broadcast that a player joined
+        var joinMessage = new JoinMessage(_room.Connections, connection);
+        _room.BroadCast(new RoomMessage<JoinMessage>("JOIN", joinMessage));
+        
+        // Create a new player, give them a new hand and add them to the game
+        var player = new Player(connection);
+        var initialHand = _deck.DrawCards(8);
+        player.GiveCards(initialHand);
+        _turnManager.Players.Add(player);
+        
+        // Broadcast new game state
+        SendGameState();
+    }
+
+    /**
+     * <inheritdoc cref="RoomType.OnDisconnect"/>
+     */
+    public override void OnDisconnect(ConnectionInstance connection)
+    {
+        // Broadcast that the player left
+        var leaveMessage = new LeaveMessage(connection);
+        _room.BroadCast(new RoomMessage<LeaveMessage>("LEAVE", leaveMessage));
+        
+        // Get the player that left
+        var player = _turnManager.Players.FirstOrDefault(x => x.IsMe(connection.Id));
+        if (player is null) return;
+        
+        // Add the player's hand to the used deck
+        var playerHand = player.Hand;
+        _deck.AddCardsToUsedDeck(playerHand);
+        
+        // Change the turn if the player that left was the current player
+        if (player == _turnManager.CurrentPlayer)
+        {
+            _turnManager.ChangeTurnTo();
+        }
+
+        // Remove the player from the game
+        _turnManager.Players.Remove(player);
+        
+        // Broadcast new game state
+        SendGameState();
+    }
+
+    /**
+     * <summary>
+     * The player had to choose a new card type
+     * </summary>
+     * <param name="player">The player that chose a new card type</param>
+     * <param name="data">A string that represents a CardType</param>
+     */
+    private void Choose(Player player, string data)
+    {
+        // Convert the data to a CardType, if it fails, ignore the message
+        if (!Enum.TryParse(data, out CardType cardType))
+        {
+            return;
+        }
+
+        // Set the next card type that is allowed to be played
+        NextAllowedCardType = cardType;
+
+        // Change the turns
+        _turnManager.ChangeTurnTo();
+        
+        // Broadcast new game state
+        SendGameState();
+    }
+
+    /**
+     * <summary>
+     * The player either:
+     * <list type="bullet">
+     *      <item>Could not play a card and had to draw a card</item>
+     *      <item>Chose to draw a card as a strategic move</item>
+     * </list>
+     * When there are multiple mau cards played, the player has to draw the combined amount of mau cards played.
+     * </summary>
+     * <param name="player">The player that drew a card</param>
+     * <param name="data">A string that can be serialized to a drawcard instance</param>
+     */
+    private void Draw(Player player)
+    {
+        // If there are cards in the MauCardBuffer, this means there are multiple cards that need to be drawn
+        // Otherwise, just draw a single card
+        if (MauCardBuffer.Count > 0)
+        {
+            // Count the amount of cards that need to be drawn
+            var totalCards = CountMauCardBuffer();
+            
+            // Draw the cards from the deck
+            var drawnCards = _deck.DrawCards(totalCards);
+            
+            // Give the cards to the player
+            player.GiveCards(drawnCards);
+            
+            // Change the turn
+            _turnManager.ChangeTurnTo();
+        }
+        else
+        {
+            // Draw a card from the deck
+            var drawnCard = _deck.DrawCard();
+
+            // Give the card to the player
+            player.GiveCard(drawnCard);
+
+            // Change the player if the drawn card cannot be played
+            if (!drawnCard.CanBePlayedOn(_deck.CurrentCard))
+            {
+                _turnManager.ChangeTurnTo();
+            }
+        }
+        
+        // Broadcast new game state
+        SendGameState();
+    }
+
+    /**
+     * <summary>
+     * The player plays a card, this will only be possible if:
+     * <list type="bullet">
+     *     <item>The player has the correct state</item>
+     *     <item>The player has the card in their hand</item>
+     *     <item>The card is playable on the current card</item>
+     * </list>
+     * </summary>
+     * <param name="player">The player that played</param>
+     * <param name="data">A string that can be serialized to a playcard instance</param>
+     */
+    private void Play(Player player, string data)
+    {
+        // Check if the player has the correct state to play a card
+        if (player.State != PlayerState.TURN)
+        {
+            return;
+        }
+
+        // Convert the data to a Card instance
+        var cardData = JsonConvert.DeserializeObject<PlayCard>(data).ToCard();
+
+        // Check if the player indeed has the card they claim to have
+        var playerCard = player.TakeCardFromHand(cardData);
+        if (playerCard is null)
+        {
+            return;
+        }
+        
+        // Check if there is a specific card type that is allowed to be played
+        if (NextAllowedCardType != null)
+        {
+            // If the card is not the allowed card type, not the same value or a joker, ignore the message
+            if (playerCard.CardType != NextAllowedCardType && playerCard.CardType != CardType.JOKER && playerCard.CardValue != _deck.CurrentCard.CardValue)
+            {
+                return;
+            }
+            // Reset the allowed card type, so the next player has the normal same type and same value rules
+            NextAllowedCardType = null;
+        } else if (MauCardBuffer.Count > 0)
+        {
+            // If there are queued mau cards, the player can only another mau card (or draw)
+            if (playerCard.CardType != CardType.JOKER && playerCard.CardValue != CardValue.TWO)
+            {
+                return;
+            }
+        }
+        else
+        {
+            // Check if the card can be played on the current card, if not, ignore the message
+            if (!playerCard.CanBePlayedOn(_deck.CurrentCard))
+            {
+                return;
+            }
+        }
+        
+        // Remove the card from the player's hand
+        player.Hand.Remove(playerCard);
+
+        // Add the card to the used deck
+        _deck.AddCardToUsedDeck(playerCard);
+
+        // Set the new current card
+        _deck.CurrentCard = playerCard;
+
+        if (player.Hand.Count == 0)
+        {
+            EndGame(player);
+            return;
+        }
+
+        // Change the turn based on the played card
+        HandleNextPlayer(playerCard);
+        
+        // Broadcast new game state
+        SendGameState();
+    }
+
+    /**
+     * <summary>
+     * Based on the played card, change the turn to the next player.
+     * </summary>
+     * <param name="card">The card that was played</param>
+     */
    private void HandleNextPlayer(Card card)
    {
        switch (card.CardValue)
@@ -96,41 +280,31 @@ public class Game
            case CardValue.RED:
            case CardValue.BLACK:
            {
-                var nextPlayer = GetNextPlayer();
-                var cardsToDraw = Deck.DrawCards(5);
-                foreach (var drawnCard in cardsToDraw)
-                {
-                    nextPlayer.Hand.Add(drawnCard);
-                }
-                CurrentPlayer.State = PlayerState.CHOOSE;
+                MauCardBuffer.Add(card);
+                _turnManager.CurrentPlayer.State = PlayerState.CHOOSE;
                break;
            }
            case CardValue.TWO:
            {
-                var nextPlayer = GetNextPlayer();
-                var cardsToDraw = Deck.DrawCards(2);
-                foreach (var drawnCard in cardsToDraw)
-                {
-                    nextPlayer.Hand.Add(drawnCard);
-                }
-                HandleNextPlayer(CurrentPlayer, GetNextPlayer(2));
+                MauCardBuffer.Add(card);
+                _turnManager.ChangeTurnTo();
                break;
            }
            case CardValue.SEVEN:
            case CardValue.KING:
                break;
            case CardValue.EIGHT:
-                HandleNextPlayer(CurrentPlayer, GetNextPlayer(2));
+                _turnManager.ChangeTurnTo(_turnManager.GetNextPlayer(2));
                break;
            case CardValue.ACE:
-                if (Players.Count > 2)
+                if (_turnManager.Players.Count > 2)
                {
-                    TurnDirection *= -1;
-                    HandleNextPlayer(CurrentPlayer, GetNextPlayer());
+                    _turnManager.ChangeDirection();
+                    _turnManager.ChangeTurnTo();
                }
                break;
            case CardValue.JACK:
-                CurrentPlayer.State = PlayerState.CHOOSE;
+                _turnManager.CurrentPlayer.State = PlayerState.CHOOSE;
                break;
            case CardValue.THREE:
            case CardValue.FOUR:
@@ -140,69 +314,63 @@ public class Game
            case CardValue.TEN:
            case CardValue.QUEEN:
            default:
-                HandleNextPlayer(CurrentPlayer, GetNextPlayer());
+                _turnManager.ChangeTurnTo();
                break;
        }
    }

-    private void HandleNextPlayer(Player current, Player next)
+    /**
+     * <summary>
+     * Count the amount of cards that need to be drawn from the MauCardBuffer. This method also clears the buffer.
+     * </summary>
+     * <returns>The amount of cards that need to be drawn</returns>
+     */
+    private int CountMauCardBuffer()
    {
-        current.State = PlayerState.WAIT;
-        next.State = PlayerState.TURN;
-        CurrentPlayer = next;
-    }
-
-    private void DrawCard(Player player)
-    {
-        player.Hand.Add(Deck.DrawCard());
-        HandleNextPlayer(player, GetNextPlayer());
-    }
-
-    private Player GetNextPlayer(int numberOfPlayers = 1)
-    {
-        var index = Players.IndexOf(CurrentPlayer);
-        for (var i = 0; i < numberOfPlayers; i++)
+        var totalCards = 0;
+        foreach (var card in MauCardBuffer)
        {
-            index += TurnDirection;
-            if (index >= Players.Count) index = 0;
-            if (index < 0) index = Players.Count - 1;
+            if (card.CardType == CardType.JOKER)
+            {
+                totalCards += 5;
+                continue;
+            }
+
+            if (card.CardValue == CardValue.TWO)
+            {
+                totalCards += 2;
+                continue;
+            }
        }
-
-        return Players[index];
+        MauCardBuffer.Clear();
+        return totalCards;
    }

-    public Player GetPlayer(string playerId)
+    /**
+     * <summary>
+     * Create a game state for each player and send it to them.
+     * By making a unique game state for each player we can hide information (like other player's hands).
+     * </summary>
+     */
+    private void SendGameState()
    {
-        return Players.FirstOrDefault(p => p.IsMe(playerId));
+        foreach (var player in _turnManager.Players)
+        {
+            var gameState = new GameState(player, _deck.CurrentCard, NextAllowedCardType, _turnManager.CurrentPlayer, _turnManager.Players);
+            player.Connection.SendMessageAsync(JsonConvert.SerializeObject(new RoomMessage<GameState>("GAME", gameState)));
+        }
    }

-    private static Card GetSameCardFromHand(IEnumerable<Card> hand, Card card)
+    /**
+     * <summary>
+     * Broadcast the winner of the game and change the room's type to a lobby.
+     * </summary>
+     * <param name="winner">The player that won the game</param>
+     */
+    private void EndGame(Player winner)
    {
-        return hand.FirstOrDefault(handCard => IsSameCard(handCard, card));
-    }
-
-    private static bool IsCardPlayable(Card currentCard, Card playedCard)
-    {
-        return IsSameCardType(currentCard, playedCard) || IsSameCardValue(currentCard, playedCard) || playedCard.CardType == CardType.JOKER;
-    }
-
-    private static bool IsCardInHand(IEnumerable<Card> hand, Card card)
-    {
-        return hand.Any(handCard => IsSameCard(handCard, card));
-    }
-
-    private static bool IsSameCard(Card card1, Card card2)
-    {
-        return IsSameCardType(card1, card2) && IsSameCardValue(card1, card2);
-    }
-
-    private static bool IsSameCardType(Card card1, Card card2)
-    {
-        return card1.CardType == card2.CardType;
-    }
-
-    private static bool IsSameCardValue(Card card1, Card card2)
-    {
-        return card1.CardValue == card2.CardValue;
+        var winMessage = new EndMessage(winner.Connection.Id, winner.Connection.Name);
+        _room.BroadCast(new RoomMessage<EndMessage>("END", winMessage));
+        _room.RoomType = new Lobby(_room);
    }
 }
--- a/Mau/GameMessages/PlayCard.cs
+++ b/Mau/GameMessages/PlayCard.cs
@@ -0,0 +1,30 @@
+namespace MauMau_Server.Mau.GameMessages;
+
+public class PlayCard
+{
+    public string CardType { get; set; }
+    public string CardValue { get; set; }
+    
+    public PlayCard(Card card)
+    {
+        CardType = card.CardType.ToString();
+        CardValue = card.CardValue.ToString();
+    }
+    
+    public PlayCard(string cardType, string cardValue)
+    {
+        CardType = cardType;
+        CardValue = cardValue;
+    }
+    
+    public PlayCard()
+    {
+        
+    }
+    
+    public Card ToCard()
+    {
+        return new Card((CardType)Enum.Parse(typeof(CardType), CardType),
+            (CardValue)Enum.Parse(typeof(CardValue), CardValue));
+    }
+}
--- a/Mau/GameState.cs
+++ b/Mau/GameState.cs
@@ -3,29 +3,30 @@
 public class GameState
 {
    public PlayerDTO Me { get; set; }
-    public string CurrentState { get; set; }
+    public string MyState { get; set; }
    public List<string> Hand { get; set; } = new();
    public string CurrentCard { get; set; }
+    public string? NextAllowedCardType { get; set; }
    public PlayerDTO CurrentPlayer { get; set; }
    public List<PlayerDTO> Players { get; set; } = new();

-    public GameState(Game game, string playerId)
+    public GameState(Player me, Card currentCard, CardType? nextAllowedCardType, Player currentPlayer, List<Player> others)
    {
-        var p = game.GetPlayer(playerId);
-        Me = new PlayerDTO(game.GetPlayer(playerId));
-        CurrentState = p.State.ToString();
-        foreach (var card in p.Hand)
+        Me = new PlayerDTO(me);
+        MyState = me.State.ToString();
+        foreach (var card in me.Hand)
        {
            Hand.Add(card.ToString());
        }
        
-        foreach (var player in game.Players)
+        foreach (var player in others)
        {
            Players.Add(new PlayerDTO(player));
        }
        
-        CurrentCard = game.CurrentCard.ToString();
-        CurrentPlayer = new PlayerDTO(game.CurrentPlayer);
+        NextAllowedCardType = nextAllowedCardType?.ToString();
+        CurrentCard = currentCard.ToString();
+        CurrentPlayer = new PlayerDTO(currentPlayer);
    }
 }

@@ -38,7 +39,7 @@ public class PlayerDTO
    public PlayerDTO(Player player)
    {
        Name = player.Connection.Name;
-        Id = player.Connection.ConnectionId;
+        Id = player.Connection.Id.ToString();
        CardsLeft = player.Hand.Count;
    }
 }
--- a/Mau/Managers/TurnManager.cs
+++ b/Mau/Managers/TurnManager.cs
@@ -0,0 +1,80 @@
+namespace MauMau_Server.Mau.Managers;
+
+public class TurnManager
+{
+    private const int CLOCKWISE = 1;
+    private const int COUNTER_CLOCKWISE = -1;
+     
+    private int _currentDirection { get; set; } = CLOCKWISE;
+    public List<Player> Players;
+    public Player CurrentPlayer;
+
+    /**
+     * <summary>
+     * Initialize the turn manager with a list of players.
+     * </summary>
+     * <param name="players">The list of players to initialize the turn manager with.</param>
+     */
+    public void Initialize(IEnumerable<Player> players)
+    {
+        Players = players.OrderBy(x => Guid.NewGuid()).ToList();
+        ShufflePlayers();
+        CurrentPlayer = Players.First();
+        CurrentPlayer.State = PlayerState.TURN;
+    }
+    
+    /**
+     * <summary>
+     * Change the direction of the turn.
+     * If the direction is clockwise, it will change to counter-clockwise and vice versa.
+     * </summary>
+     */
+    public void ChangeDirection()
+    {
+        _currentDirection *= COUNTER_CLOCKWISE;
+    }
+    
+    /**
+     * <summary>
+     * Change the turn to another player.
+     * If no player is given, the next player in the current direction is chosen.
+     * </summary>
+     * <param name="playerayer">The player to change the turn to. Defaults to the next player in the current direction.</param>
+     */
+    public void ChangeTurnTo(Player? player = null, PlayerState nextPlayerState = PlayerState.TURN)
+    {
+        var nextPlayer = player ?? GetNextPlayer();
+        CurrentPlayer.State = PlayerState.WAIT;
+        nextPlayer.State = nextPlayerState;
+        CurrentPlayer = nextPlayer;
+    }
+    
+    /**
+     * <summary>
+     * Get a player that is a given amount of players away from the current player in the current direction.
+     * </summary>
+     * <param name="numberOfPlayers">The amount of players to skip. Defaults to 1</param>
+     */
+    public Player GetNextPlayer(int numberOfPlayers = 1)
+    {
+        var playerIndex = Players.IndexOf(CurrentPlayer);
+        for (var i = 0; i < numberOfPlayers; i++)
+        {
+            playerIndex += _currentDirection;
+            if (playerIndex >= Players.Count) playerIndex = 0;
+            if (playerIndex < 0) playerIndex = Players.Count - 1;
+        }
+
+        return Players[playerIndex];
+    }
+
+    /**
+     * <summary>
+     * Shuffle the list of players for a play random order.
+     * </summary>
+     */
+    private void ShufflePlayers()
+    {
+        Players = Players.OrderBy(x => Guid.NewGuid()).ToList();
+    }
+}
--- a/Mau/Player.cs
+++ b/Mau/Player.cs
@@ -13,5 +13,25 @@ public class Player
        Connection = connection;
    }
    
-    public bool IsMe(string playerId) => Connection.ConnectionId == playerId;
+    public void GiveCard(Card card)
+    {
+        Hand.Add(card);
+    }
+    
+    public void GiveCards(IEnumerable<Card> cards)
+    {
+        Hand.AddRange(cards);
+    }
+    
+    public Card? TakeCardFromHand(Card card)
+    {
+        return Hand.FirstOrDefault(handCard => handCard.IsSameCard(card));
+    }
+    
+    public bool IsMe(Guid playerId) => Connection.Id == playerId;
+
+    public bool CanPlayCard(Card currentCard)
+    {
+        return Hand.Any(card => card.CanBePlayedOn(currentCard));
+    }
 }
--- a/Mau/PlayerState.cs
+++ b/Mau/PlayerState.cs
@@ -4,5 +4,6 @@ public enum PlayerState
 {
    TURN,
    CHOOSE,
-    WAIT
+    WAIT,
+    POST_DRAW
 }
--- a/Program.cs
+++ b/Program.cs
@@ -1,5 +1,6 @@
 using Hangfire;
 using Hangfire.MemoryStorage;
+using MauMau_Server.Room;
 using MauMau_Server.Websockets;

 var builder = WebApplication.CreateBuilder(args);
--- a/Room/Chat/Chat.cs
+++ b/Room/Chat/Chat.cs
@@ -1,34 +0,0 @@
-using System.Net.WebSockets;
-using System.Text.Json;
-using MauMau_Server.Websockets;
-
-namespace MauMau_Server.Mau;
-
-public class Chat
-{
-    private readonly Room _room;
-    
-    public Chat(Room room)
-    {
-        _room = room;
-    }
-    
-    public void SendChatMessage(ConnectionInstance connection, string message)
-    {
-        var chatMessage = new ChatMessage(connection.Name, message);
-        var formattedMessage = new MessageDTO("CHAT", JsonSerializer.Serialize(chatMessage));
-        WebsocketManager.BroadcastAsync(_room.GetWebsockets(), JsonSerializer.Serialize(formattedMessage));
-    }
-}
-
-public class ChatMessage
-{
-    public string Sender { get; set; }
-    public string Message { get; set; }
-    
-    public ChatMessage(string sender, string message)
-    {
-        Sender = sender;
-        Message = message;
-    }
-}
--- a/Room/Chat/ChatOutput.cs
+++ b/Room/Chat/ChatOutput.cs
@@ -1,18 +0,0 @@
-namespace MauMau_Server.Mau;
-
-public class ChatOutput
-{
-    public string PlayerName { get; set; }
-    public string Message { get; set; }
-    
-    public ChatOutput(string playerName, string message)
-    {
-        PlayerName = playerName;
-        Message = message;
-    }
-    
-    public ChatOutput()
-    {
-        
-    }
-}
--- a/Room/Lobby.cs
+++ b/Room/Lobby.cs
@@ -0,0 +1,33 @@
+using MauMau_Server.Mau;
+using MauMau_Server.Room.Messages;
+using MauMau_Server.Websockets;
+
+namespace MauMau_Server.Room;
+
+public class Lobby : RoomType
+{
+    public Lobby(Room room) : base(room)
+    {
+    }
+
+    public override void OnMessage(ConnectionInstance sender, RoomMessage<string> message)
+    {
+        // TODO: Add a way to change game settings
+        if (message.Type == "LOBBY" && sender == _room.Host)
+        {
+            _room.RoomType = new Game(_room, _room.Connections);
+        }
+    }
+
+    public override void OnConnect(ConnectionInstance connection)
+    {
+        var joinMessage = new JoinMessage(_room.Connections, connection);
+        _room.BroadCast(new RoomMessage<JoinMessage>("JOIN", joinMessage));
+    }
+
+    public override void OnDisconnect(ConnectionInstance connection)
+    {
+        var leaveMessage = new LeaveMessage(connection);
+        _room.BroadCast(new RoomMessage<LeaveMessage>("LEAVE", leaveMessage));
+    }
+}
--- a/Room/MessageDTO.cs
+++ b/Room/MessageDTO.cs
@@ -1,4 +1,4 @@
-namespace MauMau_Server.Mau;
+namespace MauMau_Server.Room;

 public class MessageDTO
 {
--- a/Room/Messages/ChatMessage.cs
+++ b/Room/Messages/ChatMessage.cs
@@ -0,0 +1,13 @@
+namespace MauMau_Server.Room.Messages;
+
+public class ChatMessage
+{
+    public string Sender { get; set; }
+    public string Message { get; set; }
+    
+    public ChatMessage(string sender, string message)
+    {
+        Sender = sender;
+        Message = message;
+    }
+}
--- a/Room/Messages/EndMessage.cs
+++ b/Room/Messages/EndMessage.cs
@@ -0,0 +1,13 @@
+namespace MauMau_Server.Room.Messages;
+
+public class EndMessage
+{
+    public Guid WinnerId { get; set; }
+    public string WinnerName { get; set; }
+    
+    public EndMessage(Guid winnerId, string winnerName)
+    {
+        WinnerId = winnerId;
+        WinnerName = winnerName;
+    }
+}
--- a/Room/Messages/JoinMessage.cs
+++ b/Room/Messages/JoinMessage.cs
@@ -0,0 +1,15 @@
+using MauMau_Server.Websockets;
+
+namespace MauMau_Server.Room.Messages;
+
+public class JoinMessage
+{
+    public List<ConnectionInstance> Connections { get; set; }
+    public ConnectionInstance NewConnection { get; set; }
+    
+    public JoinMessage(List<ConnectionInstance> connections, ConnectionInstance newConnection)
+    {
+        Connections = connections;
+        NewConnection = newConnection;
+    }
+}
--- a/Room/Messages/LeaveMessage.cs
+++ b/Room/Messages/LeaveMessage.cs
@@ -0,0 +1,13 @@
+using MauMau_Server.Websockets;
+
+namespace MauMau_Server.Room.Messages;
+
+public class LeaveMessage
+{
+    public ConnectionInstance Connection { get; set; }
+    
+    public LeaveMessage(ConnectionInstance connection)
+    {
+        Connection = connection;
+    }
+}
--- a/Room/Room.cs
+++ b/Room/Room.cs
@@ -1,184 +1,132 @@
 using System.Net.WebSockets;
 using System.Text.Json;
 using System.Text.RegularExpressions;
-using MauMau_Server.Mau;
+using MauMau_Server.Room.Messages;
+using MauMau_Server.Websockets;
+using Microsoft.AspNet.SignalR.Messaging;

-namespace MauMau_Server.Websockets;
+namespace MauMau_Server.Room;

 public class Room
 {
    private readonly IRoomManager _roomManager;
    private readonly string _roomId;
-    private readonly List<ConnectionInstance> _connections = new();
-    private ConnectionInstance? _host;
-    private readonly Chat _chat;
-    private Game? _game;
-    private RoomState _state = RoomState.LOBBY;
+    public readonly List<ConnectionInstance> Connections = new();
+    public ConnectionInstance? Host;
+    public RoomType RoomType;

    public Room(IRoomManager roomManager, string roomId)
    {
        _roomManager = roomManager;
-        _chat = new Chat(this);
+        RoomType = new Lobby(this);
        _roomId = roomId;
    }

    public async Task InstantiateConnection(WebSocket socket, string name)
    {
-        var connection = AddConnection(socket, name);
-        _game?.AddPlayerToGame(connection);
+        var connectionId = Guid.NewGuid();
+
+        // If the name is empty, set it to "Mau" + the first part of the connection ID, otherwise strip potential HTML from the name and use it
+        var validatedName = !string.IsNullOrWhiteSpace(name)
+            ? StripHTML(name)
+            : "Mau" + connectionId.ToString().Split('-')[0];
+        
+        var connection = new ConnectionInstance(validatedName, connectionId, socket);
+        if (IsEmpty()) Host = connection;
+        Connections.Add(connection);
+
+        RoomType.OnConnect(connection);
        await HandleConnection(connection);
    }

    private async Task HandleConnection(ConnectionInstance connection)
    {
-        BroadcastState();
        var webSocketResponse = await WebsocketManager.ReceiveAsync(connection.Socket);
        while (!webSocketResponse.Result!.CloseStatus.HasValue)
        {
-            var message = JsonSerializer.Deserialize<MessageDTO>(webSocketResponse.SlicedBuffer);
+            var message = JsonSerializer.Deserialize<RoomMessage<string>>(webSocketResponse.SlicedBuffer);
            switch (message.Type)
            {
-                case "GAME":
-                {
-                    if (_state != RoomState.GAME) break;
-                    var gameInput = JsonSerializer.Deserialize<ActionDTO>(message.Payload);
-                    _game.HandleAction(connection.ConnectionId, gameInput);
-                    break;
-                }
                case "CHAT":
-                {
-                    var cleanedMessage = StripHTML(message.Payload);
-                    if (string.IsNullOrWhiteSpace(cleanedMessage))
-                    {
-                        cleanedMessage = "Mau!";
-                    };
-                    _chat.SendChatMessage(connection, cleanedMessage);
+                    HandleChatMessage(connection, message.Data);
                    break;
-                }
-                case "LOBBY":
-                {
-                    if (connection.ConnectionId == _host?.ConnectionId)
-                    {
-                        ChangeLobbyState(RoomState.GAME);
-                    }
+                case "KICK":
+                    await HandleKick(Guid.Parse(message.Data));
+                    break;
+                default:
+                    RoomType.OnMessage(connection, message);
                    break;
-                }
            }

-            BroadcastState();
            webSocketResponse = await WebsocketManager.ReceiveAsync(connection.Socket);
        }
+
        WebsocketManager.CloseAsync(connection.Socket, webSocketResponse.Result);
-        HandleDisconnect(connection.ConnectionId);
+        HandleDisconnect(connection);
    }

-    private ConnectionInstance AddConnection(WebSocket socket, string name)
+    private void HandleChatMessage(ConnectionInstance sender, string chatMessage)
    {
-        var connectionId = Guid.NewGuid().ToString();
-        var connection = new ConnectionInstance(name, connectionId, socket);
-        if (IsEmpty()) _host = connection;
-        _connections.Add(connection);
-        return connection;
+        // Remove HTML from chat message to prevent HTML injection
+        var cleanedMessage = StripHTML(chatMessage);
+
+        // If the message is empty, set it to "Mau!"
+        if (string.IsNullOrWhiteSpace(cleanedMessage)) cleanedMessage = "Mau!";
+
+        // Create a new chat message object with the sender and the message
+        var envelope = new ChatMessage(sender.Name, cleanedMessage);
+
+        // Broadcast the chat message to all connections in the room
+        BroadCast(new RoomMessage<ChatMessage>("CHAT", envelope));
    }

-    private void RemoveConnection(string socketId)
+    private async Task HandleKick(Guid connectionId)
    {
-        _connections.RemoveAll(connection => connection.ConnectionId == socketId);
+        // Search for the connection with the given ID
+        var connection = Connections.FirstOrDefault(connection => connection.Id == connectionId);
+
+        // If the connection could not be found, return
+        if (connection == null) return;
+        
+        // Handle the disconnect of the connection
+        HandleDisconnect(connection);
+
+        // Close the connection with the reason "You have been kicked"
+        await connection.Socket.CloseAsync(WebSocketCloseStatus.NormalClosure, "You have been kicked",
+            CancellationToken.None);
    }

-    private void BroadcastGameState()
+    private void HandleDisconnect(ConnectionInstance connection)
    {
-        if (_game == null)
-        {
-            return;
-        }
-        foreach (var connection in _connections)
-        {
-            var gameState = new GameState(_game, connection.ConnectionId);
-            var message = new MessageDTO("GAME", JsonSerializer.Serialize(gameState));
-            WebsocketManager.SendAsync(connection.Socket, JsonSerializer.Serialize(message));
-        }
-    }
-
-    private void BroadcastState()
-    {
-        switch (_state)
-        {
-            case RoomState.LOBBY:
-                var message = new MessageDTO("LOBBY", JsonSerializer.Serialize("a"));
-                WebsocketManager.BroadcastAsync(GetWebsockets(), JsonSerializer.Serialize(message));
-                break;
-            case RoomState.GAME:
-                BroadcastGameState();
-                break;
-            default:
-                //
-                break;
-        }
-    }
-
-    private void ChangeLobbyState(RoomState targetState)
-    {
-        switch (targetState)
-        {
-            case RoomState.LOBBY:
-                _state = RoomState.LOBBY;
-                _game = null;
-                break;
-            case RoomState.GAME:
-            {
-                _state = RoomState.GAME;
-                _game = new Game(this);
-                foreach (var connectionInstance in _connections)
-                {
-                    _game.AddPlayerToGame(connectionInstance);
-                }
-                break;
-            }
-            default:
-                throw new ArgumentOutOfRangeException(nameof(targetState), targetState, null);
-        }
-    }
-
-    private void HandleDisconnect(string socketId)
-    {
-        RemoveConnection(socketId);
-        _game?.RemovePlayer(socketId);
+        Connections.Remove(connection);
+        RoomType.OnDisconnect(connection);
        if (IsEmpty())
        {
            _roomManager.RemoveRoom(_roomId);
+            return;
        }
-        else if (socketId == _host.ConnectionId)
+
+        if (connection == Host)
        {
-            _host = _connections.First();
+            Host = Connections.First();
        }
    }

-    public List<WebSocket> GetWebsockets()
+    public void BroadCast<T>(RoomMessage<T> message)
    {
-        return _connections.Select(connection => connection.Socket).ToList();
+        foreach (var connection in Connections)
+        {
+            connection.SendMessageAsync(JsonSerializer.Serialize(message));
+        }
    }

    public bool IsEmpty()
    {
-        return _connections.Count == 0;
+        return Connections.Count == 0;
    }

    private static string StripHTML(string input)
    {
        return Regex.Replace(input, "<.*?>", string.Empty);
    }
-
-    public void EndGame(Player player)
-    {
-        var message = new MessageDTO("END", JsonSerializer.Serialize(new PlayerDTO(player)));
-        WebsocketManager.BroadcastAsync(GetWebsockets(), JsonSerializer.Serialize(message));
-        ChangeLobbyState(RoomState.LOBBY);
-    }
-}
-
-public enum RoomState
-{
-    LOBBY,
-    GAME
 }
--- a/Room/RoomManager.cs
+++ b/Room/RoomManager.cs
@@ -1,4 +1,4 @@
-namespace MauMau_Server.Websockets;
+namespace MauMau_Server.Room;

 public class RoomManager : IRoomManager
 {
--- a/Room/RoomMessage.cs
+++ b/Room/RoomMessage.cs
@@ -0,0 +1,20 @@
+using Newtonsoft.Json;
+
+namespace MauMau_Server.Room;
+
+public class RoomMessage<T>
+{
+    public string Type { get; set; }
+    public string Data { get; set; }
+    
+    public RoomMessage(string type, T data)
+    {
+        Type = type;
+        Data = JsonConvert.SerializeObject(data);
+    }
+    
+    public RoomMessage()
+    {
+        
+    }
+}
--- a/Room/RoomType.cs
+++ b/Room/RoomType.cs
@@ -0,0 +1,38 @@
+using MauMau_Server.Websockets;
+
+namespace MauMau_Server.Room;
+
+public abstract class RoomType
+{ 
+    protected readonly Room _room;
+ 
+    protected RoomType(Room room)
+    {
+        _room = room;
+    }
+ 
+    /**
+     * <summary>
+     * This method is called when a message is received from a ConnectionInstance
+     * </summary>
+     * <param name="sender">The ConnectionInstance that sent the message</param>
+     * <param name="message">The message received</param>
+     */
+    public abstract void OnMessage(ConnectionInstance sender, RoomMessage<string> message);
+    
+    /**
+     * <summary>
+     * This method is called when a new ConnectionInstance is added to the Room.
+     * </summary>
+     * <param name="connection">The ConnectionInstance that was added to the Room</param>
+     */
+    public abstract void OnConnect(ConnectionInstance connection);
+    
+    /**
+     * <summary>
+     * This method is called when a ConnectionInstance is either removed from the Room or the ConnectionInstance's WebSocket is closed.
+     * </summary>
+     * <param name="connection">The ConnectionInstance that was removed from the Room</param>
+     */
+    public abstract void OnDisconnect(ConnectionInstance connection);
+}
--- a/Websockets/ConnectionInstance.cs
+++ b/Websockets/ConnectionInstance.cs
@@ -1,17 +1,32 @@
 using System.Net.WebSockets;
+using System.Text;
+using Newtonsoft.Json;

 namespace MauMau_Server.Websockets;

 public class ConnectionInstance
 {
+    public Guid Id { get; set; }
    public string Name { get; set; }
-    public string ConnectionId { get; set; }
+    [JsonIgnore]
    public WebSocket Socket { get; set; }
    
-    public ConnectionInstance(string name, string connectionId, WebSocket socket)
+    public ConnectionInstance(string name, Guid id, WebSocket socket)
    {
        Name = name;
-        ConnectionId = connectionId;
+        Id = id;
        Socket = socket;
    }
+    
+    /**
+     * <summary>
+     * Sends a message to the client. This method is asynchronous and formats the message to be ready to be sent.
+     * </summary>
+     */
+    public void SendMessageAsync(string message)
+    {
+        var bytes = Encoding.Default.GetBytes(message);
+        var arraySegment = new ArraySegment<byte>(bytes);
+        Socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);
+    }
 }
--- a/Websockets/WebsocketManager.cs
+++ b/Websockets/WebsocketManager.cs
@@ -5,21 +5,6 @@ namespace MauMau_Server.Websockets;

 public static class WebsocketManager
 {
-    public static void SendAsync(WebSocket socket, string message)
-    {
-        var bytes = Encoding.Default.GetBytes(message);
-        var arraySegment = new ArraySegment<byte>(bytes);
-        socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None);
-    }
-    
-    public static void BroadcastAsync(List<WebSocket> sockets, string message)
-    {
-        foreach (var socket in sockets)
-        {
-            SendAsync(socket, message);
-        }
-    }
-    
    public static async Task<WebSocketResponse> ReceiveAsync(WebSocket webSocket)
    {
        var buffer = new byte[4096];
@@ -31,6 +16,9 @@ public static class WebsocketManager
    
    public static async void CloseAsync(WebSocket webSocket, WebSocketReceiveResult result)
    {
-        await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
+        if (webSocket.State is WebSocketState.Open or WebSocketState.CloseReceived or WebSocketState.CloseSent)
+        {
+            await webSocket.CloseAsync(result.CloseStatus.Value, result.CloseStatusDescription, CancellationToken.None);
+        }
    }
 }