public async Task ClearGameInfo(SchafkopfHub hub, List <String> connectionIds) { foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync("ReceiveGameInfo", ""); } }
public async Task SendTakeTrickButton(SchafkopfHub hub, List <String> connectionIds) { foreach (Player player in PlayingPlayers) { foreach (string connectionId in player.GetConnectionIdsWithSpectators()) { if (!connectionIds.Contains(connectionId)) { continue; } if (Trick.Count < 4) { await hub.Clients.Client(connectionId).SendAsync("ReceiveTakeTrickButton", TakeTrickButtonState.hidden.ToString()); } else if (player == Trick.GetWinner()) { await hub.Clients.Client(connectionId).SendAsync("ReceiveTakeTrickButton", TakeTrickButtonState.won.ToString()); } else { await hub.Clients.Client(connectionId).SendAsync("ReceiveTakeTrickButton", TakeTrickButtonState.lost.ToString(), Trick.GetWinner().Name); } } } }
public async Task SendAskAnnounce(SchafkopfHub hub) { foreach (String connectionId in PlayingPlayers[ActionPlayer].GetConnectionIdsWithSpectators()) { await hub.Clients.Client(connectionId).SendAsync("AskAnnounce"); } }
//------------------------------------------------- // Player decides to play the game //------------------------------------------------- public async Task PlayerPlaysTheGame(Player player, SchafkopfHub hub) { if (PlayingPlayers.Count < 4 && CurrentGameState == State.Idle) { player.Playing = true; lock (PlayingPlayers) { if (!PlayingPlayers.Contains(player)) { for (int i = 0; i < PlayingPlayers.Count; i++) { if (Players.IndexOf(PlayingPlayers[i]) > Players.IndexOf(player)) { PlayingPlayers.Insert(i, player); break; } } if (!PlayingPlayers.Contains(player)) { PlayingPlayers.Add(player); } } } await SendPlayingPlayersInfo(hub); if (PlayingPlayers.Count == 4) { await DealCards(hub); } } else { //Sorry, there are too many players who want to play, what about some Netflix and Chill? } }
public async Task SendAskWantToMarryPlayer(SchafkopfHub hub, List <string> connectionIds) { foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync("AskWantToMarryPlayer", Leader.Name); } }
public async Task SendAskAnnounceHochzeit(SchafkopfHub hub) { if (AnnouncedGame == GameType.Hochzeit && PlayingPlayers.Any(p => p != Leader && !p.HasAnsweredMarriageOffer)) { foreach (Player player in PlayingPlayers.Where(p => p != Leader && !p.HasAnsweredMarriageOffer)) { await SendAskWantToMarryPlayer(hub, player.GetConnectionIdsWithSpectators()); } return; } foreach (Player player in PlayingPlayers) { if (player.HandTrumpCount(GameType.Ramsch, Color.Herz) == 1 && !player.HasBeenAskedToOfferMarriage) { foreach (String connectionId in player.GetConnectionIdsWithSpectators()) { await hub.Clients.Client(connectionId).SendAsync("AskAnnounceHochzeit"); } return; } } AnnouncedGame = GameType.Ramsch; Leader = null; CurrentGameState = State.Announce; ActionPlayer = PlayingPlayers.IndexOf(Players[StartPlayer]); await SendPlayers(hub); await SendAskAnnounce(hub); }
public async Task SendAskForGameType(SchafkopfHub hub) { for (int i = 0; i < 4; i++) { if (PlayingPlayers[ActionPlayer].WantToPlay) { // game type not anounced if (PlayingPlayers[ActionPlayer].AnnouncedGameType == GameType.Ramsch) { foreach (String connectionId in PlayingPlayers[ActionPlayer].GetConnectionIdsWithSpectators()) { await hub.Clients.Client(connectionId).SendAsync("AskGameType"); } } // game type already anounnced for everyone else { CurrentGameState = State.AnnounceGameColor; // decide who plays and ask for color DecideWhoIsPlaying(); await SendPlayers(hub); await SendAskForGameColor(hub); } return; } ActionPlayer = (ActionPlayer + 1) % 4; await SendPlayers(hub); } // no one wants to play => it's a ramsch await StartGame(hub); }
public async Task SendAskWantToSpectate(SchafkopfHub hub, List <String> connectionIds) { foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync("AskWantToSpectate", PlayingPlayers.Select(p => p.Name)); } }
public async Task SendLastTrickButton(SchafkopfHub hub, List <String> connectionIds, LastTrickButtonState state) { foreach (string connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync("ReceiveLastTrickButton", state.ToString()); } }
public async Task SendPlayerIsPlayingGameTypeAndColor(SchafkopfHub hub, List <String> connectionIds) { if (CurrentGameState != State.Playing) { return; } String message = ""; if (AnnouncedGame == GameType.Farbsolo) { message = $"{Leader.Name} spielt ein {Leader.AnnouncedColor}-Solo"; } else if (AnnouncedGame == GameType.Sauspiel) { message = $"{Leader.Name} spielt auf die {Leader.AnnouncedColor}-Sau"; } else if (AnnouncedGame == GameType.Ramsch) { message = $"Es wird geramscht!"; } else if (AnnouncedGame == GameType.Hochzeit) { message = $"{Leader.Name} (kein Trumpf) und {HusbandWife.Name} spielen eine Hochzeit!"; } else { message = $"{Leader.Name} spielt {AnnouncedGame}"; } foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync("ReceiveSystemMessage", message); await hub.Clients.Client(connectionId).SendAsync("ReceiveGameInfo", message); } }
//------------------------------------------------- // Card is added to the trick // in case that there are too many cards in one trick, an exception is thrown //------------------------------------------------- public async Task AddCard(Card card, Player player, SchafkopfHub hub, Game game) { if (Count >= 4) { throw new Exception("There are too many Cards in the trick."); } Cards[Count] = card; Player[Count] = player; await SendTrick(hub, game, game.GetPlayingPlayersConnectionIds()); if (game.LastTrick != null) { await game.SendLastTrickButton(hub, game.GetPlayingPlayersConnectionIds(), LastTrickButtonState.show); } //Determine the winner of the Trick if (Count > 0) { DetermineWinnerCard(card); } else { FirstCard = card; FirstCard.TrickValue = card.GetValue(GameType, Trump); } Count++; }
public void AddConnectionId(SchafkopfHub hub) { hub.Context.Items.Add("player", this); lock (_connectionIds) { _connectionIds.Add(hub.Context.ConnectionId); } }
//------------------------------------------------- // Player can decide what type of Game he is playing //------------------------------------------------- internal async Task AnnounceGameType(GameType gameType, SchafkopfHub hub, Game game) { AnnouncedGameType = gameType; //Message about the players actions foreach (String connectionId in game.GetPlayingPlayersConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync("ReceiveChatMessage", Name, $"Ich hätte ein {gameType}"); } }
public async Task Reset(SchafkopfHub hub) { if (CurrentGameState == State.Idle) { return; } Trick = new Trick(this, 0); await Trick.SendTrick(hub, this, GetPlayingPlayersConnectionIds()); await SendLastTrickButton(hub, GetPlayingPlayersConnectionIds(), LastTrickButtonState.disabled); await ClearGameInfo(hub, GetPlayingPlayersConnectionIds()); await SendTakeTrickButton(hub, GetPlayingPlayersConnectionIds()); CurrentGameState = State.Idle; Groups = new int[] { 0, 0, 0, 0 }; AnnouncedGame = GameType.Ramsch; Leader = null; HusbandWife = null; Trick = null; LastTrick = null; TrickCount = 0; ActionPlayer = -1; PlayingPlayers = new List <Player>(); foreach (Player player in Players) { player.Reset(); await player.SendHand(hub); } await SendPlayers(hub); foreach (String connectionId in GetPlayersConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync("CloseAnnounceModal"); await hub.Clients.Client(connectionId).SendAsync("CloseAnnounceGameTypeModal"); await hub.Clients.Client(connectionId).SendAsync("CloseGameColorModal"); await hub.Clients.Client(connectionId).SendAsync("CloseGameOverModal"); await hub.Clients.Client(connectionId).SendAsync("CloseWantToSpectateModal"); await hub.Clients.Client(connectionId).SendAsync("CloseAllowSpectatorModal"); } foreach (Player player in Players) { if (Players.Where((p => p.GetConnectionIds().Count > 0)).ToList().Count > 4) { await SendAskWantToPlay(hub, player.GetConnectionIds()); } else if (player.GetConnectionIds().Count > 0) { await PlayerPlaysTheGame(player, hub); } } }
public async Task AddSpectator(Player player, SchafkopfHub hub, Game game) { foreach (String connectionId in game.GetPlayingPlayersConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync("ReceiveSystemMessage", $"{player.Name} schaut jetzt bei {Name} zu"); } Spectators.Add(player); await game.SendUpdatedGameState(this, hub, player.GetConnectionIds()); }
public async Task SendUpdatedGameState(Player player, SchafkopfHub hub, List<string> connectionIds) { await SendPlayers(hub); if (GameState.CurrentGameState == State.Playing) { await SendPlayerIsPlayingGameTypeAndColor(hub, connectionIds); await GameState.Trick.SendTrick(hub, this, connectionIds); if (GameState.LastTrick != null) { await SendLastTrickButton(hub, connectionIds, LastTrickButtonState.show); } await player.SendHand(hub, GameState.AnnouncedGame, GameState.GetTrumpColor()); await SendTakeTrickButton(hub, connectionIds); } else { await player.SendHand(hub); await SendStartPlayer(hub, connectionIds); } // send modals if (GameState.CurrentGameState == State.Playing && GameState.TrickCount == 8) { await SendEndGameModal(hub, connectionIds); } foreach (Player p in GameState.PlayingPlayers) { if (p.GetConnectionIds().Count == 0) { await SendConnectionToPlayerLostModal(hub, connectionIds); break; } } if (GameState.ActionPlayer >= 0 && GameState.PlayingPlayers[GameState.ActionPlayer] == player) { if (GameState.CurrentGameState == State.Announce) { await SendAskAnnounce(hub); } else if (GameState.CurrentGameState == State.AnnounceGameType) { await SendAskForGameType(hub); } } if (GameState.Leader == player && GameState.CurrentGameState == State.AnnounceGameColor) { await SendAskForGameColor(hub); } if (GameState.CurrentGameState == State.AnnounceHochzeit) { await SendAskAnnounceHochzeit(hub); } if (GameState.CurrentGameState == State.HochzeitExchangeCards && player == GameState.HusbandWife) { await SendAskExchangeCards(hub, connectionIds); } }
public async Task SendAskExchangeCards(SchafkopfHub hub, List <string> connectionIds) { foreach (string connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync( "ReceiveSystemMessage", "Klicke auf die Karte, die du deinem Mitspieler geben willst." ); } }
public async Task SendPlayerIsStartingTheRound(SchafkopfHub hub, List <String> connectionIds) { foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync( "ReceiveSystemMessage", $"{PlayingPlayers[ActionPlayer].Name} kommt raus" ); } }
public async Task SendHand(SchafkopfHub hub, GameType gameType = GameType.Ramsch, Color trump = Color.Herz) { foreach (String connectionId in GetConnectionIdsWithSpectators()) { await hub.Clients.Client(connectionId).SendAsync( "ReceiveHand", HandCards.OrderByDescending(c => c.GetValue(gameType, trump)).Select(card => card.ToString()) ); } }
public async Task SendPlayersInfo(SchafkopfHub hub) { foreach (String connectionId in GetPlayersConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync( "ReceiveSystemMessage", $"Anwesende Spieler: {String.Join(", ", Players.Where(p => p.GetConnectionIds().Count > 0).Select(p => p.Name))}" ); } }
//------------------------------------------------- // The players can choose together to play another game, // there will be two options for the main-player // new game or quit //------------------------------------------------- public async Task SendEndGameModal(SchafkopfHub hub, List <String> connectionIds) { //Show the amount of pointfor each team if (AnnouncedGame > 0) { int leaderPoints = 0; int followerPoints = 0; for (int i = 0; i < 4; i++) { if (Groups[i] == 0) { followerPoints += PlayingPlayers[i].Balance; } else { leaderPoints += PlayingPlayers[i].Balance; } } string gameOverTitle = ""; if (leaderPoints <= 60) { gameOverTitle = "Die Spieler haben verloren"; } else { gameOverTitle = "Die Spieler haben gewonnen"; } foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync( "GameOver", gameOverTitle, $"Spieler: {leaderPoints} Punkte, Andere: {followerPoints} Punkte" ); } } else { List <Player> player = new List <Player>(); for (int i = 0; i < 4; i++) { player.Add(PlayingPlayers[i]); } player.OrderBy(o => o.Balance).ToList(); foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync( "GameOver", "Ramsch vorbei", String.Join(", ", player.Select(p => $"{p.Name}: {p.Balance} Punkte"))); } } }
public async Task SendPlayersInfo(SchafkopfHub hub) { foreach (String connectionId in GetPlayersConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync( "ReceivePlayersList", GameState.Players.Where(p => p.GetConnectionIds().Count > 0).Select(p => p.Name), GameState.Players.Where(p => p.GetConnectionIds().Count > 0).Select(p => p.IsPlaying == Playing.Play) ); } }
public async Task SendConnectionToPlayerLostModal(SchafkopfHub hub, List <string> connectionIds) { foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync( "GameOver", "Verbindung zu Spieler verloren", "Möchtest du neustarten oder auf den anderen Spieler warten?" ); } }
public async Task ResetIfAllConnectionsLost(SchafkopfHub hub) { foreach (Player player in PlayingPlayers) { if (player.GetConnectionIds().Count > 0) { return; } } await Reset(hub); }
public async Task StartGame(SchafkopfHub hub) { GameState.CurrentGameState = State.Playing; await SendPlayerIsPlayingGameTypeAndColor(hub, GetPlayingPlayersConnectionIds()); GameState.FindTeams(); GameState.ActionPlayer = GameState.PlayingPlayers.IndexOf(GameState.Players[GameState.StartPlayer]); GameState.NewTrick(); await SendPlayers(hub); foreach (Player player in GameState.PlayingPlayers) { await player.SendHand(hub, GameState.AnnouncedGame, GameState.GetTrumpColor()); } }
//------------------------------------------------- // Add a player to the game // The amount of player is limitless inside a game // The amount of playing players has to be excactly 4 //------------------------------------------------- public async Task AddPlayer(Player player, SchafkopfHub hub) { await SendPlayersInfo(hub); await SendPlayers(hub); if (GameState.CurrentGameState == State.Idle) { await PlayerPlaysTheGame(player, hub); } else { await SendAskWantToSpectate(hub, player.GetConnectionIds()); } }
public async Task SendStartPlayer(SchafkopfHub hub, List <String> connectionIds) { if (CurrentGameState == State.Idle || CurrentGameState == State.Playing) { return; } foreach (String connectionId in connectionIds) { await hub.Clients.Client(connectionId).SendAsync( "ReceiveGameInfo", $"{Players[StartPlayer].Name} kommt raus" ); } }
public async Task SendAskForGameColor(SchafkopfHub hub) { // Leader has to choose a color he wants to play with or a color to escort his solo if (AnnouncedGame == GameType.Sauspiel || AnnouncedGame == GameType.Farbsolo) { foreach (String connectionId in Leader.GetConnectionIdsWithSpectators()) { await hub.Clients.Client(connectionId).SendAsync("AskColor"); } } else { await StartGame(hub); } }
public async Task AskForApprovalToSpectate(SchafkopfHub hub) { if (SpectatorsWaitingForApproval.Count == 0) { foreach (String connectionId in GetConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync("CloseAllowSpectatorModal"); } return; } foreach (String connectionId in GetConnectionIds()) { await hub.Clients.Client(connectionId).SendAsync("AskAllowSpectator", SpectatorsWaitingForApproval.Peek().Name); } }
public async Task StartGame(SchafkopfHub hub) { CurrentGameState = State.Playing; await SendPlayerIsPlayingGameTypeAndColor(hub, GetPlayingPlayersConnectionIds()); FindTeams(); ActionPlayer = PlayingPlayers.IndexOf(Players[StartPlayer]); Trick = new Trick(this, ActionPlayer); await SendPlayers(hub); await SendPlayerIsStartingTheRound(hub, GetPlayingPlayersConnectionIds()); foreach (Player player in PlayingPlayers) { await player.SendHand(hub, AnnouncedGame, Trick.Trump); } }