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);
}
}
