diff --git a/Controllers/RoomController.cs b/Controllers/RoomController.cs index 7d5af5e..f6e27d7 100644 --- 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; diff --git a/Mau/ActionDTO.cs b/Mau/ActionDTO.cs index 496c375..2b72500 100644 --- 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; } diff --git a/Mau/Card.cs b/Mau/Card.cs index b9b48e4..204a1ae 100644 --- 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, diff --git a/Mau/Deck.cs b/Mau/Deck.cs index 50ffedc..e5129e8 100644 --- a/Mau/Deck.cs +++ b/Mau/Deck.cs @@ -2,47 +2,93 @@ public class Deck { - public List UnusedDeck = new(); - public List UsedDeck = new(); + private List _unusedDeck = new(); + private List _usedDeck = new(); + public Card CurrentCard; + /** + * + * Creates a new deck instance with a new shuffled set of cards + * + */ public Deck() { CreateSet(); ShuffleDeck(); + CurrentCard = DrawCard(); + _usedDeck.Add(CurrentCard); + + if (CurrentCard.CardType != CardType.JOKER) return; + CurrentCard = DrawCard(); + _usedDeck.Add(CurrentCard); + } + + /** + * + * Adds the given card to the used cards deck. + * + * The card to add to the used cards deck. + */ + public void AddCardToUsedDeck(Card card) + { + _usedDeck.Add(card); } + /** + * + * Adds the given list of cards to the used cards deck. + * + * The list of cards to add to the used cards deck. + */ + public void AddCardsToUsedDeck(IEnumerable cards) + { + _usedDeck.AddRange(cards); + } + + /** + * + * Creates a new deck of cards and adds them to the unused deck. + * + */ 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 GetUnusedDeck() - { - return UnusedDeck; - } - + /** + * + * Draws a card from the deck. + * If the deck is empty, the deck is reshuffled with . + * + */ 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 DrawCards(int amount) + /** + * + * Take a given amount of cards from the deck. This method calls for each card. + * + * The amount of cards to draw from the deck. + */ + public IEnumerable DrawCards(int amount) { var cards = new List(); for (var i = 0; i < amount; i++) @@ -51,18 +97,19 @@ public class Deck } return cards; } - - public void AddCardToUsedDeck(Card card) - { - UsedDeck.Add(card); - } + /** + * + * 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. + * + */ 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(); } + /** + * + * Shuffles all the cards in the deck using the Fisher-Yates algorithm. + * + */ private void ShuffleDeck() { - UnusedDeck = UnusedDeck.OrderBy(x => Guid.NewGuid()).ToList(); + _unusedDeck = _unusedDeck.OrderBy(x => Guid.NewGuid()).ToList(); } } \ No newline at end of file diff --git a/Mau/Game.cs b/Mau/Game.cs index 3f15e0f..8bd9804 100644 --- 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 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 MauCardBuffer = new(); + public CardType? NextAllowedCardType { get; set; } - public Game(Room room) + public Game(Room.Room room, IEnumerable 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 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(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) + /** + * + */ + public override void OnMessage(ConnectionInstance sender, RoomMessage 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; + } } + /** + * + */ + public override void OnConnect(ConnectionInstance connection) + { + // Broadcast that a player joined + var joinMessage = new JoinMessage(_room.Connections, connection); + _room.BroadCast(new RoomMessage("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(); + } + + /** + * + */ + public override void OnDisconnect(ConnectionInstance connection) + { + // Broadcast that the player left + var leaveMessage = new LeaveMessage(connection); + _room.BroadCast(new RoomMessage("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(); + } + + /** + * + * The player had to choose a new card type + * + * The player that chose a new card type + * A string that represents a CardType + */ + 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(); + } + + /** + * + * The player either: + * + * Could not play a card and had to draw a card + * Chose to draw a card as a strategic move + * + * When there are multiple mau cards played, the player has to draw the combined amount of mau cards played. + * + * The player that drew a card + * A string that can be serialized to a drawcard instance + */ + 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(); + } + + /** + * + * The player plays a card, this will only be possible if: + * + * The player has the correct state + * The player has the card in their hand + * The card is playable on the current card + * + * + * The player that played + * A string that can be serialized to a playcard instance + */ + 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(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(); + } + + /** + * + * Based on the played card, change the turn to the next player. + * + * The card that was played + */ 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) + /** + * + * Count the amount of cards that need to be drawn from the MauCardBuffer. This method also clears the buffer. + * + * The amount of cards that need to be drawn + */ + 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) + /** + * + * 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). + * + */ + 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("GAME", gameState))); + } } - private static Card GetSameCardFromHand(IEnumerable hand, Card card) + /** + * + * Broadcast the winner of the game and change the room's type to a lobby. + * + * The player that won the game + */ + 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 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("END", winMessage)); + _room.RoomType = new Lobby(_room); } } \ No newline at end of file diff --git a/Mau/GameMessages/PlayCard.cs b/Mau/GameMessages/PlayCard.cs new file mode 100644 index 0000000..aecb732 --- /dev/null +++ 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)); + } +} \ No newline at end of file diff --git a/Mau/GameState.cs b/Mau/GameState.cs index 91cac2e..bf113db 100644 --- 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 Hand { get; set; } = new(); public string CurrentCard { get; set; } + public string? NextAllowedCardType { get; set; } public PlayerDTO CurrentPlayer { get; set; } public List Players { get; set; } = new(); - public GameState(Game game, string playerId) + public GameState(Player me, Card currentCard, CardType? nextAllowedCardType, Player currentPlayer, List 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; } } \ No newline at end of file diff --git a/Mau/Managers/TurnManager.cs b/Mau/Managers/TurnManager.cs new file mode 100644 index 0000000..ad03a57 --- /dev/null +++ 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 Players; + public Player CurrentPlayer; + + /** + * + * Initialize the turn manager with a list of players. + * + * The list of players to initialize the turn manager with. + */ + public void Initialize(IEnumerable players) + { + Players = players.OrderBy(x => Guid.NewGuid()).ToList(); + ShufflePlayers(); + CurrentPlayer = Players.First(); + CurrentPlayer.State = PlayerState.TURN; + } + + /** + * + * Change the direction of the turn. + * If the direction is clockwise, it will change to counter-clockwise and vice versa. + * + */ + public void ChangeDirection() + { + _currentDirection *= COUNTER_CLOCKWISE; + } + + /** + * + * Change the turn to another player. + * If no player is given, the next player in the current direction is chosen. + * + * The player to change the turn to. Defaults to the next player in the current direction. + */ + public void ChangeTurnTo(Player? player = null, PlayerState nextPlayerState = PlayerState.TURN) + { + var nextPlayer = player ?? GetNextPlayer(); + CurrentPlayer.State = PlayerState.WAIT; + nextPlayer.State = nextPlayerState; + CurrentPlayer = nextPlayer; + } + + /** + * + * Get a player that is a given amount of players away from the current player in the current direction. + * + * The amount of players to skip. Defaults to 1 + */ + 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]; + } + + /** + * + * Shuffle the list of players for a play random order. + * + */ + private void ShufflePlayers() + { + Players = Players.OrderBy(x => Guid.NewGuid()).ToList(); + } +} \ No newline at end of file diff --git a/Mau/Player.cs b/Mau/Player.cs index 0c269c3..53074c2 100644 --- 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 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)); + } } \ No newline at end of file diff --git a/Mau/PlayerState.cs b/Mau/PlayerState.cs index a52669c..aa015f1 100644 --- a/Mau/PlayerState.cs +++ b/Mau/PlayerState.cs @@ -4,5 +4,6 @@ public enum PlayerState { TURN, CHOOSE, - WAIT + WAIT, + POST_DRAW } \ No newline at end of file diff --git a/Program.cs b/Program.cs index 16382e9..29998a0 100644 --- 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); diff --git a/Room/Chat/Chat.cs b/Room/Chat/Chat.cs deleted file mode 100644 index 338321f..0000000 --- a/Room/Chat/Chat.cs +++ /dev/null @@ -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; - } -} \ No newline at end of file diff --git a/Room/Chat/ChatOutput.cs b/Room/Chat/ChatOutput.cs deleted file mode 100644 index b7cd9c9..0000000 --- a/Room/Chat/ChatOutput.cs +++ /dev/null @@ -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() - { - - } -} \ No newline at end of file diff --git a/Room/Lobby.cs b/Room/Lobby.cs new file mode 100644 index 0000000..cd8d6ac --- /dev/null +++ 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 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("JOIN", joinMessage)); + } + + public override void OnDisconnect(ConnectionInstance connection) + { + var leaveMessage = new LeaveMessage(connection); + _room.BroadCast(new RoomMessage("LEAVE", leaveMessage)); + } +} \ No newline at end of file diff --git a/Room/MessageDTO.cs b/Room/MessageDTO.cs index 6d0fa3f..bb6ed8f 100644 --- a/Room/MessageDTO.cs +++ b/Room/MessageDTO.cs @@ -1,4 +1,4 @@ -namespace MauMau_Server.Mau; +namespace MauMau_Server.Room; public class MessageDTO { diff --git a/Room/Messages/ChatMessage.cs b/Room/Messages/ChatMessage.cs new file mode 100644 index 0000000..56b85dc --- /dev/null +++ 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; + } +} \ No newline at end of file diff --git a/Room/Messages/EndMessage.cs b/Room/Messages/EndMessage.cs new file mode 100644 index 0000000..47e88c4 --- /dev/null +++ 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; + } +} \ No newline at end of file diff --git a/Room/Messages/JoinMessage.cs b/Room/Messages/JoinMessage.cs new file mode 100644 index 0000000..b838a8e --- /dev/null +++ b/Room/Messages/JoinMessage.cs @@ -0,0 +1,15 @@ +using MauMau_Server.Websockets; + +namespace MauMau_Server.Room.Messages; + +public class JoinMessage +{ + public List Connections { get; set; } + public ConnectionInstance NewConnection { get; set; } + + public JoinMessage(List connections, ConnectionInstance newConnection) + { + Connections = connections; + NewConnection = newConnection; + } +} \ No newline at end of file diff --git a/Room/Messages/LeaveMessage.cs b/Room/Messages/LeaveMessage.cs new file mode 100644 index 0000000..9b181e1 --- /dev/null +++ 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; + } +} \ No newline at end of file diff --git a/Room/Room.cs b/Room/Room.cs index c6bda50..2b5f338 100644 --- 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 _connections = new(); - private ConnectionInstance? _host; - private readonly Chat _chat; - private Game? _game; - private RoomState _state = RoomState.LOBBY; + public readonly List 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(webSocketResponse.SlicedBuffer); + var message = JsonSerializer.Deserialize>(webSocketResponse.SlicedBuffer); switch (message.Type) { - case "GAME": - { - if (_state != RoomState.GAME) break; - var gameInput = JsonSerializer.Deserialize(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("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 GetWebsockets() + public void BroadCast(RoomMessage 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 } \ No newline at end of file diff --git a/Room/RoomManager.cs b/Room/RoomManager.cs index 4b9dab2..7735133 100644 --- a/Room/RoomManager.cs +++ b/Room/RoomManager.cs @@ -1,4 +1,4 @@ -namespace MauMau_Server.Websockets; +namespace MauMau_Server.Room; public class RoomManager : IRoomManager { diff --git a/Room/RoomMessage.cs b/Room/RoomMessage.cs new file mode 100644 index 0000000..f0c9309 --- /dev/null +++ b/Room/RoomMessage.cs @@ -0,0 +1,20 @@ +using Newtonsoft.Json; + +namespace MauMau_Server.Room; + +public class RoomMessage +{ + public string Type { get; set; } + public string Data { get; set; } + + public RoomMessage(string type, T data) + { + Type = type; + Data = JsonConvert.SerializeObject(data); + } + + public RoomMessage() + { + + } +} \ No newline at end of file diff --git a/Room/RoomType.cs b/Room/RoomType.cs new file mode 100644 index 0000000..c219066 --- /dev/null +++ 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; + } + + /** + * + * This method is called when a message is received from a ConnectionInstance + * + * The ConnectionInstance that sent the message + * The message received + */ + public abstract void OnMessage(ConnectionInstance sender, RoomMessage message); + + /** + * + * This method is called when a new ConnectionInstance is added to the Room. + * + * The ConnectionInstance that was added to the Room + */ + public abstract void OnConnect(ConnectionInstance connection); + + /** + * + * This method is called when a ConnectionInstance is either removed from the Room or the ConnectionInstance's WebSocket is closed. + * + * The ConnectionInstance that was removed from the Room + */ + public abstract void OnDisconnect(ConnectionInstance connection); +} \ No newline at end of file diff --git a/Websockets/ConnectionInstance.cs b/Websockets/ConnectionInstance.cs index 8b1884d..9a5c58c 100644 --- 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; } + + /** + * + * Sends a message to the client. This method is asynchronous and formats the message to be ready to be sent. + * + */ + public void SendMessageAsync(string message) + { + var bytes = Encoding.Default.GetBytes(message); + var arraySegment = new ArraySegment(bytes); + Socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None); + } } \ No newline at end of file diff --git a/Websockets/WebsocketManager.cs b/Websockets/WebsocketManager.cs index 8941c17..6fefe05 100644 --- 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(bytes); - socket.SendAsync(arraySegment, WebSocketMessageType.Text, true, CancellationToken.None); - } - - public static void BroadcastAsync(List sockets, string message) - { - foreach (var socket in sockets) - { - SendAsync(socket, message); - } - } - public static async Task 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); + } } } \ No newline at end of file