/// <summary>
/// Start meld round.
/// </summary>
/// <param name="trump"> Trump suit </param>
/// <returns> List of messages to be sent </returns>
private MessagePackets StartMeld(string trump)
{
MessagePackets messages = new MessagePackets();
foreach (Player p in GetPlayersMutable())
{
MeldCounter counter = new MeldCounter(p.Cards, trump, Suits.Count, Ranks.Count);
p.MeldScore = counter.TotalMeld();
MeldMessage message = new MeldMessage(p.Name, trump, p.MeldScore)
{
AcesAround = counter.AcesAround(),
KingsAround = counter.KingsAround(),
QueensAround = counter.QueensAround(),
JacksAround = counter.JacksAround(),
TrumpNine = counter.Nines(),
Run = counter.Runs(),
ClubsMarriage = counter.ClubsMarriage(),
DiamondsMarriage = counter.DiamondsMarriage(),
SpadesMarriage = counter.SpadesMarriage(),
HeartsMarriage = counter.HeartsMarriage(),
Pinochle = counter.Pinochle()
};
messages.Add(message, p.Uid);
}
return(messages);
}
/// <summary>
/// Get messages to send in response to a MeldMessage
/// </summary>
/// <param name="playerId"> The uid of the player </param>
/// <param name="meldMessage"></param>
/// <returns> List of messages to be sent </returns>
public MessagePackets HandleMeld(string playerId, MeldMessage meldMessage)
{
lock (this)
{
GameManager gm = GetGameManager(playerId);
return(Do(gm, () => gm.HandleMeld(meldMessage)));
}
}
private void HandleMeld(MeldMessage meldMessage)
{
if (meldMessage.PlayerName == PlayerName)
{
ViewController.Instance.EnableSubmitMeld(meldMessage);
}
else
{
ViewController.Instance.UpdateLog(meldMessage.PlayerName, MeldToString(meldMessage));
}
}
private string MeldToString(MeldMessage meldMessage)
{
List <string> meld = new List <string>();
if (meldMessage.AcesAround > 0)
{
meld.Add("Aces Around x" + meldMessage.AcesAround.ToString());
}
if (meldMessage.KingsAround > 0)
{
meld.Add("Kings Around x" + meldMessage.KingsAround.ToString());
}
if (meldMessage.QueensAround > 0)
{
meld.Add("Queens Around x" + meldMessage.QueensAround.ToString());
}
if (meldMessage.JacksAround > 0)
{
meld.Add("Jacks Around x" + meldMessage.JacksAround.ToString());
}
if (meldMessage.ClubsMarriage > 0)
{
meld.Add(SuitUnicodeMap["C"] + " Marriage x" + meldMessage.ClubsMarriage.ToString());
}
if (meldMessage.DiamondsMarriage > 0)
{
meld.Add(SuitUnicodeMap["D"] + " Marriage x" + meldMessage.DiamondsMarriage.ToString());
}
if (meldMessage.SpadesMarriage > 0)
{
meld.Add(SuitUnicodeMap["S"] + " Marriage x" + meldMessage.SpadesMarriage.ToString());
}
if (meldMessage.HeartsMarriage > 0)
{
meld.Add(SuitUnicodeMap["H"] + " Marriage x" + meldMessage.HeartsMarriage.ToString());
}
if (meldMessage.Pinochle > 0)
{
meld.Add("Pinochle x" + meldMessage.Pinochle.ToString());
}
if (meldMessage.Run > 0)
{
meld.Add("Run x" + meldMessage.Run.ToString());
}
if (meldMessage.TrumpNine > 0)
{
meld.Add("9 x" + meldMessage.TrumpNine.ToString());
}
string meldStr = meld.Count > 0 ? string.Join(", ", meld) : "None :(";
return("Meld: " + meldStr + " for a total of " + meldMessage.TotalPoints.ToString() + " points");
}
/// <summary>
/// Handle a MeldMessage
/// </summary>
/// <param name="meldMessage"></param>
/// <returns> List of messages to be sent </returns>
public override MessagePackets HandleMeld(MeldMessage meldMessage)
{
MessagePackets messages = new MessagePackets();
// Broadcast to all players
messages.Add(GetBroadcastMessage(meldMessage));
// Start first trick if all meld is in
NumMeld++;
if (NumMeld == GetNumPlayers())
{
NumMeld = 0;
messages.Add(StartTrick(LastBidder));
}
return(messages);
}
public void Reset()
{
Meld = null;
JacksAround.value = 0;
QueensAround.value = 0;
KingsAround.value = 0;
AcesAround.value = 0;
ClubsMarriage.value = 0;
DiamondsMarriage.value = 0;
SpadesMarriage.value = 0;
HeartsMarriage.value = 0;
Runs.value = 0;
Nines.value = 0;
Pinochles.value = 0;
TotalText.text = "0";
SubmitButton.interactable = false;
ErrorText.gameObject.SetActive(false);
}
public void SetMeld(MeldMessage meld)
{
SubmitButton.interactable = true;
Meld = meld;
UpdateTotal();
}
public void AddMessageToProcess(ServerPlayer sp, byte [] b)
{
if (b.Length < 1)
{
PhazeXLog.LogError
(
new Exception("Attempted to process 0 byte message!")
, GameLibraryVersion.ProgramIdentifier
, 0
);
}
byte start = b[0];
try
{
Message msg = null;
switch (start)
{
case (byte)pxMessages.Heartbeat:
msg = new HeartBeatMessage(b);
break;
case (byte)pxMessages.SystemMessage:
msg = new SystemMessage(b);
break;
case (byte)pxMessages.Chat:
msg = new ChatMessage(b, this.getIDs());
break;
case (byte)pxMessages.Ready:
msg = new ReadyMessage(b, this.getIDs());
break;
case (byte)pxMessages.ChangeName:
msg = new ChangeNameMessage(b, this.getIDs());
break;
case (byte)pxMessages.PlayOnGroup:
msg = new PlayOnGroupMessage(b, this.rules);
break;
case (byte)pxMessages.Meld:
msg = new MeldMessage(b, this.rules);
break;
case (byte)pxMessages.GetTopDiscard:
msg = new GetTopDiscardMessage(b);
break;
case (byte)pxMessages.GetTopDeckCard:
msg = new GetTopDeckCardMessage(b);
break;
case (byte)pxMessages.DiscardSkip:
msg = new DiscardSkipMessage(b, this.getIDs(), this.rules);
break;
case (byte)pxMessages.Discard:
msg = new DiscardMessage(b, this.rules);
break;
case (byte)pxMessages.RequestHand:
msg = new RequestHandMessage(b);
break;
case (byte)pxMessages.RequestTable:
msg = new RequestTableMessage(b);
break;
default:
msg = new UnknownMessage(b);
break;
}
lock (this)
{
_messagesToProcess.Add(new PlayerMessage(sp, msg));
}
}
catch (BadMessageException bme)
{
PhazeXLog.LogError
(
bme
, GameLibraryVersion.ProgramIdentifier
, 109
);
string info = "";
foreach (byte tmp in b)
{
info += ((int)tmp).ToString() + " ";
}
PhazeXLog.LogInformation(info, pid);
}
}
private void handleMeldMessage(MeldMessage m, ServerPlayer p)
{
if (!p.MyTurn)
{
p.Send(new ErrorMessage("It is not your turn to meld! Returning cards."));
p.Send(new HandMessage(p.GetHand(), true));
return; //client sent invalid request!
}
if (p.CompletedPhaze)
{
p.Send(new ErrorMessage("You have already completed your phaze! Returning cards."));
p.Send(new HandMessage(p.GetHand(), true));
return; //client sent invalid request!
}
List <Group> lg = m.Groups;
//check that this doesn't use ALL of the player's cards!
int num_cards = 0;
foreach (Group g in lg)
{
num_cards += g.Count;
}
if (num_cards > this.rules.HandCards)
{
//invalid request!
p.Send(new ErrorMessage("You cannot meld with ALL of the cards in your hand! You must keep one card to discard with!"));
p.Send(new HandMessage(p.GetHand(), true));
return;
}
//check that all cards are from the user's hand
//string card_data = "";
bool okay = true;
bool correct = true;
foreach (Group g in lg)
{
foreach (Card c in g)
{
if (!p.GetHand().HasCardWithId(c.Id))
{
okay = false;
}
if (!g.Check())
{
correct = false;
}
if ((!okay) || (!correct))
{
break;
}
}
if ((!okay) || (!correct))
{
break;
}
}
if (!okay)
{
//invalid request
p.Send(new ErrorMessage("You do not own any of the cards you are trying to play! Returning all cards."));
p.Send(new HandMessage(p.GetHand(), true));
return;
}
if (!correct)
{
//invalid request
p.Send(new ErrorMessage("Meld is invalid! Returning all cards."));
p.Send(new HandMessage(p.GetHand(), true));
return;
}
//if we've reached here, we can officially remove all cards
//and add the groups to the table
foreach (Group g in lg)
{
foreach (Card c in g)
{
p.GetHand().RemoveCardWithId(c.Id);
}
_table.AddGroup(g);
}
p.CompletedPhaze = true;
p.Send(new HandMessage(p.GetHand(), false));
SendAll(new CompletedPhazeMessage(p.PlayerID));
SendAll(new TableMessage(_table));
updateClientsStatuses();
}
/// <summary>
/// Handle a MeldMessage. By default, do nothing.
/// Subclasses should override to enable different behaviors.
/// </summary>
/// <param name="meldMessage"></param>
/// <returns> List of messages to be sent </returns>
public virtual MessagePackets HandleMeld(MeldMessage meldMessage)
{
throw GetNotSupportedException("MeldMessage");
}
public void EnableSubmitMeld(MeldMessage meldMessage)
{
MeldSheet.SetMeld(meldMessage);
}
private void HandleMessage(string message)
{
try
{
lock (MessageTasks)
{
ErrorResponse errorResponse = JsonConvert.DeserializeObject <ErrorResponse>(message);
if (errorResponse.IsValid())
{
Debug.Log("ErrorResponse: " + errorResponse.ErrorMessage);
return;
}
DisconnectMessage disconnectMessage = JsonConvert.DeserializeObject <DisconnectMessage>(message);
if (disconnectMessage.IsValid())
{
HandleDisconnect(disconnectMessage);
return;
}
RestartMessage restartMessage = JsonConvert.DeserializeObject <RestartMessage>(message);
if (restartMessage.IsValid())
{
HandleRestart(restartMessage);
return;
}
GameTypeMessage gameTypeMessage = JsonConvert.DeserializeObject <GameTypeMessage>(message);
if (gameTypeMessage.IsValid())
{
ViewController.Instance.UpdateGameTypes(gameTypeMessage.GameTypes);
return;
}
JoinResponse joinResponse = JsonConvert.DeserializeObject <JoinResponse>(message);
if (joinResponse.IsValid())
{
HandleJoinResponse(joinResponse);
return;
}
AvailableGamesMessage gamesMessage = JsonConvert.DeserializeObject <AvailableGamesMessage>(message);
if (gamesMessage.IsValid())
{
ViewController.Instance.UpdateAvailableGames(gamesMessage.AvailableGames);
return;
}
JoinMessage joinMessage = JsonConvert.DeserializeObject <JoinMessage>(message);
if (joinMessage.IsValid())
{
HandleJoin(joinMessage);
return;
}
StartMessage startMessage = JsonConvert.DeserializeObject <StartMessage>(message);
if (startMessage.IsValid())
{
HandleStart(startMessage);
return;
}
BidMessage bidMessage = JsonConvert.DeserializeObject <BidMessage>(message);
if (bidMessage.IsValid())
{
HandleBid(bidMessage);
return;
}
KittyMessage kittyMessage = JsonConvert.DeserializeObject <KittyMessage>(message);
if (kittyMessage.IsValid())
{
HandleKitty(kittyMessage);
return;
}
TrumpMessage trumpMessage = JsonConvert.DeserializeObject <TrumpMessage>(message);
if (trumpMessage.IsValid())
{
HandleTrump(trumpMessage);
return;
}
MeldPointsMessage meldPointsMessage = JsonConvert.DeserializeObject <MeldPointsMessage>(message);
if (meldPointsMessage.IsValid())
{
HandleMeldPoints(meldPointsMessage);
return;
}
MeldMessage meldMessage = JsonConvert.DeserializeObject <MeldMessage>(message);
if (meldMessage.IsValid())
{
HandleMeld(meldMessage);
return;
}
PassMessage passMessage = JsonConvert.DeserializeObject <PassMessage>(message);
if (passMessage.IsValid())
{
HandlePass(passMessage);
return;
}
ScoreMessage scoreMessage = JsonConvert.DeserializeObject <ScoreMessage>(message);
if (scoreMessage.IsValid())
{
HandleScore(scoreMessage);
return;
}
TurnMessage turnMessage = JsonConvert.DeserializeObject <TurnMessage>(message);
if (turnMessage.IsValid())
{
HandleTurn(turnMessage);
return;
}
TrickMessage trickMessage = JsonConvert.DeserializeObject <TrickMessage>(message);
if (trickMessage.IsValid())
{
HandleTrick(trickMessage);
return;
}
TrickInfoMessage trickInfoMessage = JsonConvert.DeserializeObject <TrickInfoMessage>(message);
if (trickInfoMessage.IsValid())
{
HandleTrickInfo(trickInfoMessage);
return;
}
GameOverMessage gameOverMessage = JsonConvert.DeserializeObject <GameOverMessage>(message);
if (gameOverMessage.IsValid())
{
HandleGameOver(gameOverMessage);
return;
}
}
}
catch (Exception err)
{
Debug.Log("OnMessage error: " + err.Message);
Debug.Log("OnMessage stack trace: " + err.StackTrace);
}
}
public void SubmitMeld(MeldMessage message)
{
ViewController.Instance.UpdateLog(message.PlayerName, MeldToString(message));
ViewController.Instance.ShowMeldWindow(false);
MessageServer(message);
}
private MessagePackets HandleMessage(string message)
{
RestartMessage restartMessage = JsonConvert.DeserializeObject <RestartMessage>(message);
if (restartMessage.IsValid())
{
return(GamesManager.Get().HandleRestart(ID, restartMessage));
}
GameTypeMessage gameTypeMessage = JsonConvert.DeserializeObject <GameTypeMessage>(message);
if (gameTypeMessage.IsValid())
{
return(GamesManager.Get().HandleGameTypes(ID, gameTypeMessage));
}
JoinMessage joinMessage = JsonConvert.DeserializeObject <JoinMessage>(message);
if (joinMessage.IsValid())
{
return(GamesManager.Get().HandleJoin(ID, joinMessage));
}
BidMessage bidMessage = JsonConvert.DeserializeObject <BidMessage>(message);
if (bidMessage.IsValid())
{
return(GamesManager.Get().HandleBid(ID, bidMessage));
}
KittyMessage kittyMessage = JsonConvert.DeserializeObject <KittyMessage>(message);
if (kittyMessage.IsValid())
{
return(GamesManager.Get().HandleKitty(ID, kittyMessage));
}
TrumpMessage trumpMessage = JsonConvert.DeserializeObject <TrumpMessage>(message);
if (trumpMessage.IsValid())
{
return(GamesManager.Get().HandleTrump(ID, trumpMessage));
}
MeldMessage meldMessage = JsonConvert.DeserializeObject <MeldMessage>(message);
if (meldMessage.IsValid())
{
return(GamesManager.Get().HandleMeld(ID, meldMessage));
}
PassMessage passMessage = JsonConvert.DeserializeObject <PassMessage>(message);
if (passMessage.IsValid())
{
return(GamesManager.Get().HandlePass(ID, passMessage));
}
TurnMessage turnMessage = JsonConvert.DeserializeObject <TurnMessage>(message);
if (turnMessage.IsValid())
{
return(GamesManager.Get().HandleTurn(ID, turnMessage));
}
return(new MessagePackets());
}
