private void ProcessBid(Packet p) { BidMessage bidMsg = (BidMessage)p.message; // Debug.Log ("Processing bid for Agent " + p.src.ID + " on tile " + bidMsg.tileId + " with amount " + bidMsg.bidAmount); /* Determine if the agent should bid for a different tile */ SearchTileBid recvBid = new SearchTileBid(p.src.ID, bidMsg.bidAmount); if (this.goalTile == null && this.bidKnowledge.CandidateTile != null && bidMsg.tileId == this.bidKnowledge.CandidateTile.id) //&& this.canidateBid != null // If the recv bid is better than my bid, reset { if (recvBid.IsBetterThan(this.bidKnowledge.CandidateBid)) { this.bidKnowledge.CandidateTile.SetAsClaimed(recvBid); this.bidKnowledge.ResetCandidateAndGoalTile(); } } else if (this.goalTile != null && bidMsg.tileId == this.goalTile.id) { // If the recv bid is better than my claimed bid, give up on that tile and assert that the other // if (recvBid.IsBetterThan(this.goalTile.acceptedBid)) { this.goalTile.acceptedBid = recvBid; this.bidKnowledge.ResetCandidateAndGoalTile(); // this.sender.SendClaimed (bidMsg.tileId, recvBid.agentId, recvBid.value); } } bidKnowledge.AddBidForTile(bidMsg.tileId, new SearchTileBid(p.src.ID, bidMsg.bidAmount)); }
private void HandleBid(BidMessage bidMessage) { ViewController.Instance.DoOnClear(() => { if (bidMessage.Bid < 0) { if (bidMessage.PlayerName == PlayerName) { ViewController.Instance.ShowBidWindow(true, bidMessage.CurBid); } else { ViewController.Instance.UpdateLog(bidMessage.PlayerName, "Bidding..."); } } else if (bidMessage.Bid == bidMessage.CurBid) { ViewController.Instance.UpdateBidInfo(bidMessage.PlayerName, bidMessage.Bid.ToString()); ViewController.Instance.UpdateLog(SystemString, "The final bid is " + bidMessage.Bid.ToString() + " by " + bidMessage.PlayerName); } else { string bidStr = bidMessage.Bid == 0 ? "Pass" : string.Format("Bid {0}", bidMessage.Bid.ToString()); ViewController.Instance.UpdateLog(bidMessage.PlayerName, bidStr); } }); }
/// <summary> /// Parses a single quote message from a reading file. /// </summary> /// <param name="r">the <c>BinaryReader</c> object reading the target file.</param> /// <returns>The parsed <c>QuoteMessage</c> object or null if all available objects have been read.</returns> private QuoteMessage ReadQuoteMessage() { try { QuoteMessage result = null; int length = IPAddress.NetworkToHostOrder(m_reader.ReadInt32()); ushort funcCode = Bytes.NetworkToHostOrder(m_reader.ReadUInt16()); int bodyLength = IPAddress.NetworkToHostOrder(m_reader.ReadInt32()); byte[] body = new byte[length]; int count = m_reader.Read(body, BidMessage.HeaderLength, bodyLength); if (count == bodyLength) { result = (QuoteMessage)BidMessage.Create(FunctionCodes.Quote, body, 0, length); } return(result); } catch (EndOfStreamException) { return(null); } }
private void HandleBidMessage(BidMessage message) { Console.WriteLine("CLIENT: received bid message"); Bid b = message.Bid; Form1.GetInstance().UpdateTextBox(b.ToString()); }
/// <summary> /// Get messages to send in response to a BidMessage /// </summary> /// <param name="playerId"> The uid of the player </param> /// <param name="bidMessage"></param> /// <returns> List of messages to be sent </returns> public MessagePackets HandleBid(string playerId, BidMessage bidMessage) { lock (this) { GameManager gm = GetGameManager(playerId); return(Do(gm, () => gm.HandleBid(bidMessage))); } }
private static List <long> get_relevant_suppliers(BidMessage msg) { Int64 cityId = get_bid_city(msg.BidId); var query = get_relevant_suppliers_query(cityId, msg.BidId); List <long> supplierIds = get_relevant_suppliers(query); return(supplierIds); }
public void sendEmail() { var bid = new BidMessage { BidId = 123 }; BIdMessageController.send_message_to_admin(bid); }
private static void send_message_to_admin(BidMessage msg) { try { EmailMessagingService.SendEmailUntakenBidToAdmin(msg); } catch (Exception) { } }
private static long get_primium_supplier(BidMessage msg) { Int64 cityId = get_bid_city(msg.BidId); var query = get_relevant_premium_suppliers_query(cityId, msg.BidId); List <long> supplierIds = get_relevant_suppliers(query); long prioritized = _prioritizedSuppliers.FirstOrDefault(x => supplierIds.Contains(x)); if (prioritized > 0) { return(prioritized); } return(supplierIds.FirstOrDefault()); }
private AuctionLibrary.Message CreateBidMessage(string args) { //Implement BID message string search = args; string[] result = search.Split(':'); string productName = result[0]; int bidAmount = Convert.ToInt32(result[1]); AuctionLibrary.Message msg = new BidMessage(productName, bidAmount); return(msg); }
/// <summary> /// Examines the entire buffer and parses all <c>QuoteMessage</c>s in it. /// </summary> private void ParseMessages() { while (m_writeIndex - m_readIndex > BidMessage.HeaderLength) { int length = 0; ushort funcCode = 0; int bodyLength = 0; for (; m_writeIndex - m_readIndex >= BidMessage.HeaderLength; m_readIndex++) { int offset = m_readIndex; length = m_buffer.ToInt32(offset); offset += sizeof(int); funcCode = m_buffer.ToUInt16(offset); offset += sizeof(ushort); bodyLength = m_buffer.ToInt32(offset); if (length - bodyLength == BidMessage.HeaderLength) { break; } } // loop guard is true iff the next message is successfully located // break if this fails or only part of next message is found if (m_writeIndex - m_readIndex < BidMessage.HeaderLength || m_writeIndex - m_readIndex < length) { break; } if (funcCode == (ushort)FunctionCodes.Quote) { QuoteMessage message = (QuoteMessage)BidMessage.Create(FunctionCodes.Quote, m_buffer, m_readIndex, length); OnQuoteMessageReceived(message); } m_readIndex += length; } // incomplete message if (m_readIndex != 0) { Array.Copy(m_buffer, m_readIndex, m_buffer, 0, m_writeIndex - m_readIndex); m_writeIndex -= m_readIndex; m_readIndex = 0; } }
/// <summary> /// Uses the credentials to authenticate with the remote server. /// Goes to states <c>Create</c>, <c>Receive</c>, and <c>Close</c>. /// </summary> /// <returns>Time to wait till next state is run, in milliseconds.</returns> private int Authenticate() { ChangeStatus(QuoteProviderStatus.Authenticate); try { SessionKeyRequestMessage sessionKeyRequest = new SessionKeyRequestMessage(m_username); int length = sessionKeyRequest.GetBytes(m_buffer, 0); int count = m_client.Send(m_buffer, 0, length, SocketFlags.None); count = m_client.Receive(m_buffer); length = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(m_buffer, 0)); SessionKeyReplyMessage sessionKeyReply = (SessionKeyReplyMessage)BidMessage.Create(FunctionCodes.SessionKeyReply, m_buffer, 0, length); uint sessionKey = sessionKeyReply.SessionKey; LoginRequestMessage LoginRequest = new LoginRequestMessage(m_username, m_password, sessionKey); length = LoginRequest.GetBytes(m_buffer, 0); count = m_client.Send(m_buffer, 0, length, SocketFlags.None); count = ReceiveMessage(); length = IPAddress.NetworkToHostOrder(BitConverter.ToInt32(m_buffer, 0)); LoginReplyMessage loginReply = (LoginReplyMessage)BidMessage.Create(FunctionCodes.LoginReply, m_buffer, 0, length); m_maxHeartbeatInterval = loginReply.MaxHeartbeatInterval; if (m_maxHeartbeatInterval > 0) { m_retryTimes = 0; m_readIndex = m_writeIndex = 0; m_lastReception = m_lastHeartbeat = (uint)Environment.TickCount; m_runByState = Receive; } else { throw new Exception("Invalid login."); } } catch (SocketException se) { OnErrorOccurred(se, false); return(RetryOrGiveup(m_status)); } catch (Exception ex) { OnErrorOccurred(ex, true); m_runByState = Close; } return(0); }
static public void SendNewBidToSupplier(BidMessage msg) { string Key = Settings.Keys.EMAIL_TEMPLATE_SUPPLIER_NEW_BID; AppSupplier supplier = SupplierUI.FetchByID(msg.SupplierId); int TemplateId = GetEmailTemplateIdFromSettingKey(Key, supplier.LangCode); EmailTemplate template = TemplateId == 0 ? null : EmailTemplateController.GetItem(TemplateId); if (template != null) { string fromEmail = template.FromEmail; string fromName = template.FromName; string replyToEmail = template.ReplyToEmail; string replyToName = template.ReplyToName; if (string.IsNullOrEmpty(fromEmail)) { fromEmail = Settings.GetSetting(Settings.Keys.DEFAULT_EMAIL_FROM); } if (string.IsNullOrEmpty(fromName)) { fromName = Settings.GetSetting(Settings.Keys.DEFAULT_EMAIL_FROM_NAME); } if (string.IsNullOrEmpty(replyToEmail)) { replyToEmail = Settings.GetSetting(Settings.Keys.DEFAULT_EMAIL_REPLYTO); } if (string.IsNullOrEmpty(replyToName)) { replyToName = Settings.GetSetting(Settings.Keys.DEFAULT_EMAIL_REPLYTO_NAME); } Dictionary <string, string> dictFieldHtml = new Dictionary <string, string>(); dictFieldHtml.Add(@"BIDID", msg.BidId.ToString()); string subject = EmailTemplateController.ReplaceSharpsInString(template.Subject, dictFieldHtml); string body = EmailTemplateController.ReplaceSharpsInString(template.Body, dictFieldHtml); bool isProduction = Convert.ToBoolean(AppConfig.GetString(@"IsProduction", @"false")); string emailTo = isProduction ? supplier.Email:AppConfig.GetString(@"DevMailAddress", @""); System.Net.Mail.MailMessage message = EmailTemplateController.BuildMailMessage( fromEmail, fromName, replyToEmail, replyToName, emailTo, template.CcList, template.BccList, subject, body, null, template.MailPriority); EmailTemplateController.Send(message, EmailLogController.EmailLogType.OnError, true, 5); } }
private static BidMessage get_message_by_bid_and_supplier(Int64 bidId, Int64 supplierId) { var qry = new Query(BidMessage.TableSchema); qry.Where(BidMessage.Columns.BidId, bidId); qry.AddWhere(BidMessage.Columns.SupplierId, supplierId); using (DataReaderBase reader = qry.ExecuteReader()) { if (reader.Read()) { BidMessage item = new BidMessage(); item.Read(reader); return(item); } } return(null); }
private void HandleBidMessage(BidMessage message) { Console.WriteLine("USER Received BidMessage"); Bid b = message.Bid; foreach (Car c in Server.Cars) { if (c.CarID == b.CarId) { Car CurrentCar = c; Console.WriteLine("Bieding toegevoegd!"); //Server.BroadcastAsync(new CarMessage(CurrentCar)); Server.Bids.Add(b); Server.BroadcastAsync(new BidMessage(b)); Console.WriteLine("Auto gebroadcast!"); } } }
public static List <BidMessage> GetAllMessagesByBidId(long bidId) { var qry = new Query(BidMessage.TableSchema); qry.AddWhere(BidMessage.Columns.BidId, WhereComparision.EqualsTo, bidId); var messageList = new List <BidMessage>(); using (DataReaderBase reader = qry.ExecuteReader()) { while (reader.Read()) { BidMessage item = new BidMessage(); item.Read(reader); messageList.Add(item); } } return(messageList); }
public static Int64 AddNewMessage(Int64 bidId, Int64 supplierId, long originalSupplierId = 0, string state = START_STAGE) { using (ConnectorBase conn = ConnectorBase.NewInstance()) { //BidMessage message = get_message_by_bid_and_supplier(bidId, supplierId); // if (message != null) return 0; BidMessage message = new BidMessage(); message.BidId = bidId; message.SupplierId = supplierId; message.Stage = state; message.IsActive = true; message.ExpirationTime = DateTime.Now; message.SendingTime = DateTime.Now; message.OriginalSupplierId = originalSupplierId == 0? supplierId : originalSupplierId; message.Save(conn); return(message.MessageId); } }
/// <summary> /// Handle a BidMessage. /// </summary> /// <param name="bidMessage"></param> /// <returns> List of messages to be sent </returns> public override MessagePackets HandleBid(BidMessage bidMessage) { MessagePackets messages = new MessagePackets(); // Broadcast bid to all players messages.Add(GetBroadcastMessage(bidMessage)); // Parse bid CurBid = bidMessage.Bid; if (bidMessage.Bid != 0) { LastBidder = GetCurrentPlayerIndex(); } else { CurBid = bidMessage.CurBid; PassedPlayers.Add(GetCurrentPlayerIndex()); } // Get next non-passed player NextPlayer(); while (PassedPlayers.Contains(GetCurrentPlayerIndex()) && GetCurrentPlayerIndex() != LastBidder) { NextPlayer(); } // Handle last bid if (GetCurrentPlayerIndex() == LastBidder) { messages.Add(GetBroadcastMessage(new BidMessage(GetCurrentPlayer().Name, CurBid, CurBid))); PassedPlayers = new List <int>(); messages.Add(StartKitty(GetCurrentPlayerIndex())); } // Initiate next bid else { Player player = GetCurrentPlayer(); messages.Add(GetBroadcastMessage(new BidMessage(player.Name, CurBid))); } return(messages); }
internal static List <BidMessage> GetAllRelevantMessages(DateTime now) { var qry = new Query(BidMessage.TableSchema); qry.Where(BidMessage.Columns.IsActive, true); qry.AddWhere(BidMessage.Columns.ExpirationTime, WhereComparision.LessThan, now); var messageList = new List <BidMessage>(); using (DataReaderBase reader = qry.ExecuteReader()) { while (reader.Read()) { BidMessage item = new BidMessage(); item.Read(reader); messageList.Add(item); } } return(messageList); }
static public void SendEmailUntakenBidToAdmin(BidMessage msg) { string Key = Settings.Keys.EMAIL_UNTAKEN_BID; int TemplateId = GetEmailTemplateIdFromSettingKey(Key, "he-IL"); string fromEmail = Settings.GetSetting(Settings.Keys.DEFAULT_EMAIL_FROM); string fromName = Settings.GetSetting(Settings.Keys.DEFAULT_EMAIL_FROM_NAME);; string replyToEmail = Settings.GetSetting(Settings.Keys.ADMIN_EMAIL); string replyToName = "Admin"; string subject = "Transaction number " + msg.BidId + " has not completed!"; string body = "Nobody responded to BidId: " + msg.BidId; string to = Settings.GetSetting(Settings.Keys.ADMIN_EMAIL); System.Net.Mail.MailMessage message = EmailTemplateController.BuildMailMessage( fromEmail, fromName, replyToEmail, replyToName, to, "*****@*****.**", "", subject, body, null, null, new List <string> { to }); EmailTemplateController.Send(message, EmailLogController.EmailLogType.OnError, true); }
/// <summary> /// Handle a BidMessage. By default, do nothing. /// Subclasses should override to enable different behaviors. /// </summary> /// <param name="bidMessage"></param> /// <returns> List of messages to be sent </returns> public virtual MessagePackets HandleBid(BidMessage bidMessage) { throw GetNotSupportedException("BidMessage"); }
private static BidMessage DecodeBidMessage(dynamic json) { BidMessage msg = BidMessage.ToClass(json); return(msg); }
/// <summary> /// Processes messages recieved from client. /// If message is a sucessful login, server will return product list. /// If message is /// </summary> /// <param name="s"></param> /// <param name="msgType"></param> /// <returns></returns> public string ProcessMessage(string s, string msgType) { string[] splitter = s.Split('#'); string msg = splitter[0]; string ID = splitter[1]; // Retrieve message from client serializedmsg = msg; //Check to see what type of message it is JsonDeserializer rm = new JsonDeserializer(); string returnmsg = ""; switch (msgType) { case "Login": LoginMessage login = rm.DeserializeLoginMessage(serializedmsg); string valid = c.ValidateLogin(login.userName, login.password); switch (valid) { case "Good": { AddUser(ID, login.userName); //Serialize list of product returnmsg = "Login#" + JsonConvert.SerializeObject(p.GetProduct); break; } case "New": case "Bad": { returnmsg = "Failed#failed"; break; } default: break; } //Add to the list if it is new user if (valid == "New") { c.Add(login.userName, login.password); } break; case "Bid": BidMessage bid = rm.DeserializeBidMessage(msg); bool validProduct = ValidateBid(bid.productName, bid.bidAmount); if (validProduct) { returnmsg = "Bid#" + JsonConvert.SerializeObject(p.GetProduct); AddTopBid(bid.productName, ID); } else { returnmsg = "BadBid#" + JsonConvert.SerializeObject(p.GetProduct); } break; default: break; } return(returnmsg); }
internal static void SendMessages(List <BidMessage> messages, DateTime now) { foreach (var msg in messages) { switch (msg.Stage) { case START_STAGE: WaitingEmails.Enqueue(msg); SupplierNotification.SendNotificationNewBidToSupplier(msg.BidId, new List <Int64> { msg.SupplierId }); msg.ExpirationTime = now.AddMinutes(Settings.GetSettingInt64(Settings.Keys.MESSAGE_EXPIRATION_SUPPLIER, 60)); msg.Stage = SUPPLIER_STAGE; msg.Save(); break; case PREMIUM_STAGE: case SUPPLIER_STAGE: long supplierId = get_primium_supplier(msg); if (supplierId == 0) { goto case SPECIAL_DEAL_STAGE; } SupplierNotification.SendNotificationNewBidToPremiumSupplier(msg.BidId, supplierId); var newPremMessage = new BidMessage(msg); newPremMessage.Stage = PREMIUM_STAGE; newPremMessage.SupplierId = supplierId; newPremMessage.ExpirationTime = now.AddMinutes(Settings.GetSettingInt64(Settings.Keys.MESSAGE_EXPIRATION_PREMIUM, 20)); newPremMessage.Save(); WaitingEmails.Enqueue(newPremMessage); goto default; case SPECIAL_DEAL_STAGE: var supplierList = get_relevant_suppliers(msg); if (supplierList.Count <= 0) { var bid = Bid.FetchByID(msg.BidId); if (!bid.IsActive) { goto default; } goto case ADMIN_STAGE; } foreach (int sId in supplierList) { var newSpecMessage = new BidMessage(msg); newSpecMessage.SupplierId = sId; newSpecMessage.ExpirationTime = now.AddMinutes(Settings.GetSettingInt64(Settings.Keys.MESSAGE_EXPIRATION_SPECIAL_DEAL, 10)); newSpecMessage.Stage = SPECIAL_DEAL_STAGE; newSpecMessage.IsActive = false; newSpecMessage.Save(); SupplierNotification.SendNotificationNewBidToPremiumSupplier(msg.BidId, sId); WaitingEmails.Enqueue(newSpecMessage); } var forAdminMessage = new BidMessage(msg); forAdminMessage.ExpirationTime = now.AddMinutes(Settings.GetSettingInt64(Settings.Keys.MESSAGE_EXPIRATION_SPECIAL_DEAL, 10)); forAdminMessage.Stage = SPECIAL_DEAL_STAGE; forAdminMessage.IsActive = true; forAdminMessage.SupplierId = 1; forAdminMessage.Save(); goto default; case ADMIN_STAGE: var expiredDid = Bid.FetchByID(msg.BidId); expiredDid.IsActive = false; expiredDid.Save(); msg.Stage = ADMIN_STAGE; send_message_to_admin(msg); goto default; default: msg.IsActive = false; msg.Save(); break; } } }
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); } }
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()); }