private RawCard GetRawCard(String suit, String value)
{
RawCard card;
switch (suit)
{
case "Red":
card = new RawCard(ESuit.Red, Int32.Parse(value));
return(card);
case "Yellow":
card = new RawCard(ESuit.Yellow, Int32.Parse(value));
return(card);
case "Blue":
card = new RawCard(ESuit.Blue, Int32.Parse(value));
return(card);
case "Green":
card = new RawCard(ESuit.Green, Int32.Parse(value));
return(card);
}
return(null);
}
public Boolean SendTrumpCard(RawCard card, Player specificPlayer = null)
{
if (runState == State.Server)
{
if (specificPlayer == null)
{
try {
foreach (Player player in playerList.GetPlayers())
{
NetworkComms.SendObject("TrumpCard", player.IP, player.Port, card);
}
return(true);
} catch (Exception e) {
baseClass.NetworkError("[SendTrumpCard] SendTrumpCard: " + e.Message);
}
}
else
{
try {
NetworkComms.SendObject("TrumpCard", specificPlayer.IP, specificPlayer.Port, card);
return(true);
} catch (Exception e) {
baseClass.NetworkError("[SendTrumpCard] SendTrumpCard: " + e.Message);
}
}
}
return(false);
}
public RawCard draw()
{
RawCard card = cards[0];
cards.Remove(card);
return(card);
}
public void HostTrumpPlayed(RawCard trump)
{
if (MainGame.Instance.HostOnly)
{
debugOut("Trump received");
client.playTrump(trump);
clientData.newRound();
}
}
public void TrumpCardReceived(RawCard card, Boolean restoringState = false)
{
if (MainGame.Instance.HostOnly)
{
debugOut("Trump received");
client.playTrump(card);
clientData.newRound();
}
}
public void TrumpCardReceived(RawCard card, Boolean restoringState = false)
{
debugOut("Trump received");
client.playTrump(card);
lastReceivedBid = null;
if (!restoringState)
{
clientData.newRound();
}
}
public void playTrump(RawCard trump)
{
if (frameHand.IsActive)
{
frameHand.table.setTrump(new Card(trump, new Vector2(screenSize.X * 0.5f, 0f)));
}
else
{
frameTable.setTrump(new Card(trump, new Vector2(screenSize.X * 0.5f, 0f)));
}
}
public void playCard(RawCard card)
{
if (frameHand.IsActive)
{
frameHand.table.playCard(new Card(card, new Vector2(screenSize.X * 0.5f, 0f)));
}
else
{
frameTable.playCard(new Card(card, new Vector2(screenSize.X * 0.5f, 0f)));
}
}
public void bringToTop(RawCard raw)
{
Card card = cards.Find(x => x.Raw.Equals(raw));
if (card == null)
{
return;
}
cards.Remove(card);
cards.Insert(cards.Count, card);
}
public bool removeCard(RawCard raw)
{
int index = cards.FindIndex(x => x.Raw.Equals(raw));
if (index == -1)
{
return(false);
}
cards.RemoveAt(index);
return(true);
}
public void sendToBottom(RawCard raw)
{
Card card = cards.Find(x => x.Raw.Equals(raw));
if (card == null)
{
return;
}
cards.Remove(card);
cards.Insert(0, card);
}
public RawCard waitForNextCard()
{
receivedCard = null;
while (receivedCard == null)
{
;
}
RawCard card = receivedCard;
receivedCard = null;
return(card);
}
private Boolean AddCardToHands(RawCard card)
{
if (runState == State.Server)
{
if (!restoringState && !cardsInHands.Contains(card) && !roundPlayedCards.Contains(card))
{
cardsInHands.Add(card);
}
return(true);
}
return(false);
}
public void HostCardPlayed(RawCard card, Player player)
{
if (MainGame.Instance.HostOnly)
{
debugOut("Card received");
card.Player = player.ID;
client.playCard(card);
clientData.cardPlayed(card, player.ID);
AudioHelper.play(ContentStore.soundSlide);
}
}
private void TrumpCardHandler(PacketHeader header, Connection connection, RawCard card)
{
if (!IsCorrectPort(connection))
{
return;
}
Thread.Sleep(SLEEP_TIME);
while (card == null)
{
;
}
baseClass.TrumpCardReceived(card);
}
public void HistoryTrumpCardDealt(RawCard card)
{
Card cardToAdd = new Card(card);
cardsInHands.addCard(cardToAdd);
if (playingLastTrick)
{
foreach (Player p in UltraServer.Instance.network.Players.GetPlayers())
{
UltraServer.Instance.network.SendCard(cardToAdd.Raw, p);
}
}
}
private Boolean RemoveCardFromHands(RawCard card)
{
if (runState == State.Server)
{
if (!restoringState && cardsInHands.Contains(card))
{
trickPlayedCards.Add(card);
roundPlayedCards.Add(card);
}
return(true);
}
return(false);
}
public void HistoryCardDealt(RawCard card, Player player)
{
Card cardToAdd = new Card(card);
cardToAdd.Raw.Player = player.ID;
cardsInHands.addCard(cardToAdd);
if (playingLastRound)
{
if (cardsInHands.getCards().Contains(cardToAdd))
{
UltraServer.Instance.network.SendCard(card, player);
}
}
}
public Card(RawCard raw, Vector2 position, float rotation, float scale)
{
this.raw = raw;
this.hitbox = new LinePoly(
Vector2.Zero,
new Vector2(-20, -32),
new Vector2(20, -32),
new Vector2(20, 32),
new Vector2(-20, 32)
);
resize(scale - 1);
blink(position);
rotate(rotation);
cardTextureHelper = CardTextureHelper.getInstance();
}
public void TrickWinnerReceived(Player winner)
{
while (winner == null)
{
;
}
debugOut("Trick winner received (" + winner.Name + ")");
MainGame.Instance.GeneralMessageQueue.Enqueue(network.Players.GetPlayerByID(winner.ID).Name + " won the trick!");
clientData.trickWon(winner.ID);
AudioHelper.play(ContentStore.soundGood);
lastReceivedCard = null;
Thread.Sleep(2000);
client.frameTable.clearTrick();
client.frameHand.table.clearTrick();
clientData.trickStart();
}
private void CardHandler(PacketHeader header, Connection connection, RawCard card)
{
if (!IsCorrectPort(connection))
{
return;
}
Thread.Sleep(SLEEP_TIME);
while (card == null)
{
;
}
if (runState == State.Server)
{
RemoveCardFromHands(card);
}
receivedCard = card;
baseClass.CardReceived(card);
}
public Boolean SendCard(RawCard card, Player player)
{
if (runState == State.Server && player != null)
{
if (!restoringState)
{
RawCard cardToAdd = new RawCard(card.Suit, card.Number);
while (cardToAdd == null)
{
;
}
cardToAdd.Player = player.ID;
AddCardToHands(cardToAdd);
}
try {
NetworkComms.SendObject("Card", player.IP, player.Port, card);
// Thread.Sleep(100);
// if (!restoringState) AddCardToHands(cardToAdd);
} catch (Exception e) {
baseClass.NetworkError("[SendCard] SendCard: " + e.Message);
return(false);
}
}
else if (runState == State.Client && player == null)
{
try {
if (!CheckConnection())
{
return(false);
}
NetworkComms.SendObject("Card", serverIP, serverPort, card);
} catch (Exception e) {
baseClass.NetworkError("[SendCard] SendCard: " + e.Message);
return(false);
}
}
else
{
baseClass.NetworkError("[Method] SendCard: player should be null if the client is sending to the server. If the server is sending to the client, player should not be null.");
}
return(true);
}
public void cardPlayed(RawCard card, int playerID)
{
trickCards[playerID - 1] = card;
if (leadSuit == null && !leadWizard)
{
if (card.Number == 15)
{
leadWizard = true;
}
else if (card.Number != 1)
{
leadSuit = card.Suit;
if (LeadSuitChanged != null)
{
LeadSuitChanged(this, new ChangedSuit(leadSuit));
}
}
}
}
public void HistoryCardReceived(RawCard card, Player player)
{
Card cardToRemove = new Card(card);
cardToRemove.Raw.Player = player.ID;
UltraServer.Instance.CardReceived(card);
if (playingLastTrick)
{
if (cardsInHands.getCards().Contains(cardToRemove))
{
foreach (Player p in UltraServer.Instance.network.Players.GetPlayers())
{
UltraServer.Instance.network.SendCard(cardToRemove.Raw, p);
}
}
}
cardsInHands.removeCard(cardToRemove);
}
public void shuffle()
{
cards = new List <RawCard>();
for (int i = 0; i < 4; i++)
{
for (int j = 1; j <= 15; j++)
{
cards.Add(new RawCard((ESuit)i, j));
}
}
// KNUTH SHUFFLE
rand = new Random();
for (int i = cards.Count - 1; i > 0; i--)
{
int j = rand.Next(0, i);
RawCard swap = cards[j];
cards[j] = cards[i];
cards[i] = swap;
}
}
public void CardReceived(RawCard card)
{
debugOut("Card received");
if (card == lastReceivedCard)
{
return;
}
if (card.Player != -1)
{
client.playCard(card);
clientData.cardPlayed(card, card.Player);
}
else
{
client.dealtCard(card);
}
lastReceivedCard = card;
AudioHelper.play(ContentStore.soundSlide);
}
public void dealtCard(RawCard card)
{
playerHand.addCard(new Card(card, new Vector2(screenSize.X * 0.5f, 0f)));
}
public EventTrumpCardDealt(RawCard trumpCard)
{
this.trumpCard = trumpCard;
}
private void SetupRejoinedPlayer(Player oldPlayer, Player newPlayer)
{
if (!gameStarted)
{
return;
}
restoringState = true;
Thread.Sleep(SLEEP_TIME);
SendStartGameMessage(newPlayer);
Thread.Sleep(SLEEP_TIME);
Console.WriteLine(newPlayer.IP + ":" + newPlayer.Port);
SendTrumpCard(GameScheduler.LastTrumpCard, newPlayer);
Thread.Sleep(SLEEP_TIME);
foreach (RawCard card in cardsInHands)
{
try {
if (card.Player == newPlayer.ID && !roundPlayedCards.Contains(card))
{
RawCard cardToSend = new RawCard(card.Suit, card.Number, card.Player);
Thread.Sleep(250);
cardToSend.Player = -1;
SendCard(cardToSend, newPlayer);
Console.WriteLine("[Rejoin] Hand card sent");
Thread.Sleep(SLEEP_TIME);
}
} catch (Exception e) {
Console.WriteLine("[Rejoin error] " + e.Message);
}
}
Console.WriteLine("[Rejoin] After cardsInHands");
foreach (RawCard card in trickPlayedCards)
{
SendCard(card, newPlayer);
Thread.Sleep(SLEEP_TIME);
Console.WriteLine("[Rejoin] Played card sent");
}
Console.WriteLine("[Rejoin] After playedCards");
foreach (Bid bid in bidsInRound)
{
SendBid(bid, newPlayer);
Thread.Sleep(SLEEP_TIME);
Console.WriteLine("[Rejoin] Bid sent");
}
Console.WriteLine("[Rejoin] After bidsInRound");
if (lastRequestPlayer.ID == newPlayer.ID && lastBidRequest != null)
{
RequestBid(newPlayer, lastBidRequest.MaxBid);
}
else if (lastRequestPlayer.ID == newPlayer.ID && lastCardRequest != null)
{
RequestCard(newPlayer);
}
Thread.Sleep(SLEEP_TIME);
Console.WriteLine("[Rejoin] After request sending");
foreach (Score score in scores.GetAllScores())
{
try {
NetworkComms.SendObject("Score", newPlayer.IP, newPlayer.Port, score);
Thread.Sleep(SLEEP_TIME);
} catch (Exception e) {
Console.WriteLine("[SetupRejoinedPlayer] Exception " + e.Message);
}
}
Console.WriteLine("[Rejoin] After score sending");
restoringState = false;
GameScheduler.UpdatePlayer(oldPlayer, newPlayer);
}
public static void schedulerThread()
{
// GAME START
for (int round = 1; round <= numRounds; round++)
{
// ROUND START
network.StartNewRound();
deck.shuffle();
Player dealersLeft = leadPlayer.Peek();
// DEAL CARDS
for (int p = 0; p < leadPlayer.Count; p++)
{
network.SendPing();
wait_handle.WaitOne();
debugOut("Dealing Cards to Player " + leadPlayer.ToArray()[p].ID);
for (int i = 0; i < round; i++)
{
networkingCheck(() => network.SendCard(deck.draw(), leadPlayer.ToArray()[p]));
Thread.Sleep(SLEEP_TIME);
}
}
Thread.Sleep(SLEEP_TIME);
// DEAL TRUMP
RawCard trump = deck.draw();
lastTrumpCard = trump;
network.SendPing();
wait_handle.WaitOne();
networkingCheck(() => network.SendTrumpCard(trump));
server.HostTrumpPlayed(trump);
debugOut("Trump Dealt");
for (int p = 0; p < leadPlayer.Count; p++)
{
// REQUEST BID
network.SendPing();
wait_handle.WaitOne();
networkingCheck(() => network.RequestBid(leadPlayer.ToArray()[p], round));
debugOut("Bid Requested");
Bid bid = network.waitForNextBid();
debugOut("Bid Received");
network.ClearLastRequest();
UltraServer.Instance.Bids.AddBid(bid);
server.HostBidReceived(bid);
// BROADCAST BID
for (int q = 0; q < players.Count; q++)
{
network.SendPing();
wait_handle.WaitOne();
networkingCheck(() => network.SendBid(bid, players.ToArray()[q]));
debugOut("Bid Sent");
}
network.ClearBids();
Thread.Sleep(SLEEP_TIME);
}
debugOut("Beginning Tricks");
Player trickWinner = leadPlayer.Peek();
for (int trick = 1; trick <= round; trick++)
{
// TRICK START
Trick trickObj = new Trick(trump);
while (leadPlayer.Peek().ID != trickWinner.ID)
{
leadPlayer.Enqueue(leadPlayer.Dequeue());
}
for (int p = 0; p < leadPlayer.Count; p++)
{
// REQUEST CARD
rejoinedPlayer = null;
network.SendPing();
wait_handle.WaitOne();
networkingCheck(() => network.RequestCard(leadPlayer.ToArray()[p]));
debugOut("Card Requested");
RawCard card = network.waitForNextCard();
debugOut("Card Received");
network.ClearLastRequest();
server.HostCardPlayed(card, leadPlayer.ToArray()[p]);
// PLAY CARD
trickObj.playCard(card, leadPlayer.ToArray()[p].ID);
// BROADCAST CARD
card.Player = leadPlayer.ToArray()[p].ID;
for (int q = 0; q < players.Count; q++)
{
network.SendPing();
wait_handle.WaitOne();
networkingCheck(() => network.SendCard(card, players.ToArray()[q]));
Thread.Sleep(SLEEP_TIME);
}
Thread.Sleep(SLEEP_TIME);
}
debugOut("Resolving Trick");
// RESOLVE TRICK
int winnerID = trickObj.resolveTrick();
// BROADCAST TRICK WINNER
trickWinner = players.Find(x => x.ID == winnerID);
network.SendPing();
wait_handle.WaitOne();
networkingCheck(() => network.SendTrickWinner(trickWinner));
UltraServer.Instance.Bids.TrickWon(trickWinner);
debugOut("Trick Resolved");
Thread.Sleep(2000);
server.HostEndOfTrick(trickWinner);
}
network.SendPing();
wait_handle.WaitOne();
UltraServer.Instance.CalculateScores(); // Calculates (and broadcasts via the Network class) scores
foreach (Score score in network.Scores.GetAllScores())
{
debugOut(network.Players.GetPlayerByID(score.ID).Name + " bid " + ": " + score.Value);
server.HostScoreReceived(score);
}
// ROTATE DEALER
while (leadPlayer.Peek() != dealersLeft)
{
leadPlayer.Enqueue(leadPlayer.Dequeue());
}
leadPlayer.Enqueue(leadPlayer.Dequeue());
debugOut("Round End");
// ROUND END
}
server.EndGame();
}
