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