public override void SendChatMessage(string message)
{
ServerMessagePacket serverMessage = new ServerMessagePacket()
{
Message = message
};
AssociatedPeer.Send(ServerPacketHandler.Instance.WriteSerializable(PacketType.ServerMessage, serverMessage), DeliveryMethod.ReliableUnordered);
}
private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
{
if (txtNick.Text != null)
{
UserPacket user = new UserPacket(txtNick.Text, comboBox1.Text);
client.SendMessage(user);
ServerMessagePacket server = new ServerMessagePacket(txtNick.Text + " is now " + comboBox1.Text + ".");
client.SendMessage(server);
}
}
private void btnNick_Click_1(object sender, EventArgs e)
{
//NickNamePacket nickname = new NickNamePacket(txtNick.Text);
UserPacket user = new UserPacket(txtNick.Text, "Online");
client.SendMessage(user);
ServerMessagePacket message = new ServerMessagePacket(txtNick.Text + " has joined the chat.");
client.SendMessage(message);
txtNick.Enabled = false;
btnNick.Enabled = false;
btnSend.Enabled = true;
}
static byte[] GetBytesFromPacket(ServerMessagePacket packet)
{
int size = System.Runtime.InteropServices.Marshal.SizeOf(packet);
byte[] bytes = new byte[size];
IntPtr ptr = Marshal.AllocHGlobal(size);
Marshal.StructureToPtr(packet, ptr, true);
Marshal.Copy(ptr, bytes, 0, size);
Marshal.FreeHGlobal(ptr);
return(bytes);
}
public Packet TCPRead()
{
try
{
int numberOfBytes;
if ((numberOfBytes = _reader.ReadInt32()) != -1)
{
byte[] buffer = _reader.ReadBytes(numberOfBytes);
MemoryStream memoryStream = new MemoryStream(buffer);
Packet packet = _binaryFormatter.Deserialize(memoryStream) as Packet;
switch (packet.EPacketType)
{
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)packet;
return(new ChatMessagePacket(Decrypt(chatMessagePacket.OriginClient), Decrypt(chatMessagePacket.Message)));
case PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessagePacket = (ServerMessagePacket)packet;
return(new ServerMessagePacket(Decrypt(serverMessagePacket.Message)));
case PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)packet;
return(new PrivateMessagePacket(Decrypt(privateMessagePacket.OriginClient), Decrypt(privateMessagePacket.PrivateMessage)));
case PacketType.ANNOUNCEMESSAGE:
AnnouncementMessagePacket announcementMessagePacket = (AnnouncementMessagePacket)packet;
return(new AnnouncementMessagePacket(Decrypt(announcementMessagePacket.Message)));
}
return(packet);
}
else
{
return(null);
}
}
catch (Exception e)
{
Console.WriteLine("[Error] " + e.Message + e.StackTrace);
return(null);
}
}
public void TCPSend(Packet packet)
{
lock (_writeLock)
{
try
{
//encrypt relevant packets
switch (packet.EPacketType)
{
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)packet;
Serialize(new ChatMessagePacket(Encrypt(chatMessagePacket.OriginClient), Encrypt(chatMessagePacket.Message)));
break;
case PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessagePacket = (ServerMessagePacket)packet;
Serialize(new ServerMessagePacket(Encrypt(serverMessagePacket.Message)));
break;
case PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)packet;
Serialize(new PrivateMessagePacket(Encrypt(privateMessagePacket.OriginClient), Encrypt(privateMessagePacket.PrivateMessage)));
break;
case PacketType.ANNOUNCEMESSAGE:
AnnouncementMessagePacket announcementMessagePacket = (AnnouncementMessagePacket)packet;
Serialize(new AnnouncementMessagePacket(Encrypt(announcementMessagePacket.Message)));
break;
default:
Serialize(packet);
break;
}
}
catch (Exception e)
{
Console.WriteLine("[Error] " + e.Message + e.StackTrace);
}
}
}
void TcpClientMethod(int index)
{
Console.WriteLine("Socket opened. (" + _tcpListener.ToString() + ")");
Packet receivedPacket;
Client client = _clients[index];
try {
while ((receivedPacket = client.TcpRead()) != null)
{
Console.Write("TCP Receieved: ");
// act on packet type
switch (receivedPacket._packetType)
{
case Packet.PacketType.EMPTY:
Console.WriteLine("EMPTY");
/* do nothing */
break;
case Packet.PacketType.CHATMESSAGE:
Console.WriteLine("CHAT");
TcpRespondToAll((ChatMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.PRIVATEMESSAGE:
Console.WriteLine("PRIVATE");
TcpRespondTo((PrivateMessagePacket)receivedPacket, client);
break;
case Packet.PacketType.SERVERMESSAGE:
Console.WriteLine("SERVER");
ServerMessagePacket servPacket = (ServerMessagePacket)receivedPacket;
servPacket._messageRecv = GetReturnMessage(servPacket._messageSent);
client.TcpSend(servPacket);
break;
case Packet.PacketType.CLIENTNAME:
Console.WriteLine("NAME");
ClientNamePacket namePacket = (ClientNamePacket)receivedPacket;
// create message
namePacket._message = client._name + " changed name to " + namePacket._name;
// change name
client._name = namePacket._name;
// update client
client.TcpSend(namePacket);
// notify all clients
TcpRespondToAll(new ChatMessagePacket(namePacket._message), client);
break;
case Packet.PacketType.LOGIN:
Console.WriteLine("LOGIN");
LoginPacket loginPacket = (LoginPacket)receivedPacket;
client._endPoint = loginPacket._endPoint;
loginPacket._serverKey = client.UpdateRSA(loginPacket);
client.TcpSend(loginPacket);
break;
case Packet.PacketType.SECUREMESSAGE:
Console.WriteLine("SECURE");
// receive packet
SecurePacket safePacket = (SecurePacket)receivedPacket;
// transmit packet
TcpSecureRespondToAll(
client.GetSecureMessage(safePacket),
safePacket._packetSrc
);
break;
case Packet.PacketType.ERROR:
//should be for other things, in another place
Console.WriteLine("ERROR");
ErrorMessagePacket errPacket = (ErrorMessagePacket)receivedPacket;
client.TcpSend(errPacket);
break;
case Packet.PacketType.ENDSESSION:
Console.Write("ENDING TCP SESSION: " + client._name);
// signal to client to close connections
// and end while loop
client.Close();
break;
case Packet.PacketType.JOINGAME:
Console.Write("JOIN GAME - ");
JoinGamePacket joinGame = (JoinGamePacket)receivedPacket;
Client host = null;
foreach (Client user in _clients.Values)
{
if (user._name == joinGame._targetHost)
{
host = user;
}
}
//ChatMessagePacket resultPacket = null;
if (GameSession.Instance.JoinSession(ref client, host))
{
Console.WriteLine("JOINED A GAME");
//success - msg client
PrivateMessagePacket resultPacket =
new PrivateMessagePacket(client._name, "Started Game Session")
{
_packetSrc = _serverName
};
TcpRespondTo(resultPacket, client);
//launch client's game
client.TcpSend(joinGame);
}
else
{
Console.WriteLine("FAILED TO JOIN A GAME");
//failed - msg client
};
break;
case Packet.PacketType.USERLIST:
Console.WriteLine("USERLIST");
UserListPacket userList = (UserListPacket)receivedPacket;
if (userList._users == null)
{
List <string> usernames = new List <string>();
// collect user names
foreach (KeyValuePair <int, Client> c in _clients)
{
usernames.Add(c.Value._name);
}
userList._users = usernames.ToArray();
TcpSendToAll(userList);
}
// if list is filled, why is it here?!
break;
case Packet.PacketType.LEAVEGAME:
LeaveGamePacket leaveGame = (LeaveGamePacket)receivedPacket;
// check game sessions
bool wasHost = GameSession.Instance.IsHosting(client);
// update game session
List <string> players = GameSession.Instance.LeaveSession(ref client);
ServerMessagePacket serverMessage = null;
if (!leaveGame._wasForced)
{
serverMessage = new ServerMessagePacket
(client._name + " has left the game.", null);
}
else
{
serverMessage = new ServerMessagePacket
("GAME ERROR: " + client._name + " was forced to leave the game.", null);
}
foreach (Client user in _clients.Values)
{
if (players.Contains(user._name))
{
user.TcpSend(serverMessage);
}
}
if (wasHost)
{
leaveGame._wasForced = true;
foreach (Client user in _clients.Values)
{
user.TcpSend(leaveGame);
}
}
break;
default:
break;
}
}
} catch (Exception e) {
Console.WriteLine("Error: " + e.Message);
if (client != null)
{
Console.WriteLine("Client: " + client._name);
}
}
client.Close();
_clients.TryRemove(index, out client);
}
private void TCPClientMethod(int index)
{
Packet receivedPacket;
//loop to allow continuous communication
while((receivedPacket = _clients[index].TCPRead()) != null)
{
try
{
switch (receivedPacket.EPacketType)
{
case PacketType.EMPTY:
EmptyPacket emptyPacket = (EmptyPacket)receivedPacket;
break;
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)receivedPacket;
try
{
//reencrypt data into new packet so that all the clients are able to decrypt it with their private key
ChatMessagePacket sendPacket = new ChatMessagePacket(UTF8.GetBytes(_clients[index].clientData.clientNickname), chatMessagePacket.Message)
{
Time = chatMessagePacket.Time
};
//send messages to all clients
TCPSendPacketToAll(sendPacket);
//print client messages to server console
OutputLog(chatMessagePacket.Time + " " + _clients[index].clientData.clientNickname + ": " + UTF8.GetString(chatMessagePacket.Message));
}
catch (Exception e)
{
OutputLog("[Error] " + e.Message + e.StackTrace);
break;
}
break;
case PacketType.COMMANDMESSAGE:
CommandMessagePacket commandMessagePacket = (CommandMessagePacket)receivedPacket;
//Process command
ProcessCommand(_clients[index], UTF8.GetString(commandMessagePacket.Message));
break;
case PacketType.CLIENTNAME:
ClientNamePacket clientNamePacket = (ClientNamePacket)receivedPacket;
bool uniqueName = true;
for(int i = 0; i < _clients.Count; i++)
{
if(UTF8.GetString(clientNamePacket.ClientName) == _clients[i].clientData.clientNickname)
{
uniqueName = false;
}
}
if(uniqueName)
{
OutputLog("[Nickname] " + _clients[index].clientData.clientNickname + " has changed their nickname to " + UTF8.GetString(clientNamePacket.ClientName) + ".");
_clients[index].clientData.clientNickname = UTF8.GetString(clientNamePacket.ClientName);
//Refresh client list
ClientListPacket clientListPacket = new ClientListPacket(GetClientNames(), GetClientAddresses());
TCPSendPacketToAll(clientListPacket);
//Send name change confirmation
ServerMessagePacket serverMessagePacket = new ServerMessagePacket(UTF8.GetBytes("Your server nickname has been changed to " + UTF8.GetString(clientNamePacket.ClientName) + "!"));
_clients[index].TCPSend(serverMessagePacket);
}
else
{
//Send name change failed
ServerMessagePacket serverMessagePacket = new ServerMessagePacket(UTF8.GetBytes("Someone on this server already has the nickname '" + UTF8.GetString(clientNamePacket.ClientName) + "'. Please choose a different nickname!"));
_clients[index].TCPSend(serverMessagePacket);
}
break;
case PacketType.DISCONNECTREQUEST:
DisconnectRequestPacket disconnectRequestPacket = (DisconnectRequestPacket)receivedPacket;
//Announce client has joined to all clients
ServerMessagePacket serverMessagePacket3 = new ServerMessagePacket(UTF8.GetBytes(_clients[index].clientData.clientNickname + " has left the server!"));
TCPSendPacketToAll(serverMessagePacket3);
_clients[index].Close();
break;
case PacketType.LOGIN:
LoginPacket loginPacket = (LoginPacket)receivedPacket;
try
{
//set server client ip and client key
_clients[index].clientData.ipEndPoint = loginPacket.EndPoint;
_clients[index]._clientKey = loginPacket.PublicKey;
//send server public key back
ServerKeyPacket serverKeyPacket = new ServerKeyPacket(_clients[index]._publicKey, true);
_clients[index].TCPSend(serverKeyPacket);
_clients[index].successfulLogin = true;
//Announce client has joined to all clients
ServerMessagePacket serverMessagePacket2 = new ServerMessagePacket(UTF8.GetBytes(_clients[index].clientData.clientNickname + " has joined the server!"));
TCPSendPacketToAll(serverMessagePacket2);
//Refresh client list
ClientListPacket clientListPacket2 = new ClientListPacket(GetClientNames(), GetClientAddresses());
TCPSendPacketToAll(clientListPacket2);
break;
}
catch (Exception e)
{
OutputLog("[Error] " + e.Message + e.StackTrace);
break;
}
}
}
catch (Exception e)
{
OutputLog("[Error] " + e.Message + e.StackTrace);
break;
}
}
try
{
_clients[index].Close();
//Take client out of client ConcurrentBag
_clients.TryRemove(index, out Client c);
}
catch (Exception e)
{
OutputLog("[Error] " + e.Message + e.StackTrace);
}
}
private void ProcessCommand(Client client, string command)
{
try
{
ServerMessagePacket serverMessagePacket;
ChatMessagePacket chatMessagePacket;
string[] parameters = SplitCommandIntoParameters(command);
//////////////////////////////////
switch ((parameters[0].ToUpper()).TrimStart('/'))
{
case "HELLO":
//send server reponse
serverMessagePacket = new ServerMessagePacket(UTF8.GetBytes("Hello!"));
client.TCPSend(serverMessagePacket);
break;
case "PM":
int clientDestination = -1;
for(int i = 0; i < _clients.Count; i++)
{
if(parameters[1] == _clients[i].clientData.clientNickname)
{
//check if the destination is the same as the sender
if(_clients[i] == client)
{
clientDestination = -2;
break;
}
else
{
clientDestination = i;
break;
}
}
}
//check if there is a message
if(parameters[2] == null)
{
ServerMessagePacket serverMessagePacket1 = new ServerMessagePacket(UTF8.GetBytes("Please put a message after the nickname!"));
client.TCPSend(serverMessagePacket1);
}
//check if client was found with name
else if(clientDestination > -1)
{
//send private message to destination client
PrivateMessagePacket privateMessagePacket = new PrivateMessagePacket(UTF8.GetBytes(client.clientData.clientNickname), UTF8.GetBytes(parameters[2].ToString()));
_clients[clientDestination].TCPSend(privateMessagePacket);
//send confirmation to user that their private message has been sent and has arrived
PrivateMessagePacket privateMessagePacket1 = new PrivateMessagePacket(UTF8.GetBytes(parameters[2].ToString()), UTF8.GetBytes(_clients[clientDestination].clientData.clientNickname));
client.TCPSend(privateMessagePacket1);
//log pm to server console
OutputLog(privateMessagePacket.Time + " [PM] " + UTF8.GetString(privateMessagePacket.OriginClient) + " -> " + _clients[clientDestination].clientData.clientNickname + ": " + UTF8.GetString(privateMessagePacket.PrivateMessage));
}
else if (clientDestination == -1)
{
ServerMessagePacket serverMessagePacket2 = new ServerMessagePacket(UTF8.GetBytes("Sorry that client does not exist. Please try again with a real nickname!"));
client.TCPSend(serverMessagePacket2);
}
else if (clientDestination == -2)
{
ServerMessagePacket serverMessagePacket3 = new ServerMessagePacket(UTF8.GetBytes("You can't send private messages to yourself silly!"));
client.TCPSend(serverMessagePacket3);
}
break;
case "HELP":
ServerMessagePacket serverMessagePacket4 = new ServerMessagePacket(UTF8.GetBytes("\nCommands: \n/HELLO - Hello! \n/PM [NAME] [MSG] - Send private messages! \n/ROLLDICE [NumOfDices] [NumOfFaces] - Roll dice! \n/ANNOUNCE [MSG] - Send an announcement message to everyone on the server!"));
client.TCPSend(serverMessagePacket4);
break;
case "ROLLDICE":
ServerMessagePacket serverMessagePacket5;
if (!(String.IsNullOrEmpty(parameters[1]) || String.IsNullOrEmpty(parameters[2])))
{
serverMessagePacket5 = new ServerMessagePacket(UTF8.GetBytes(RollDice(Int32.Parse(parameters[1]), Int32.Parse(parameters[2]))));
}
else
{
serverMessagePacket5 = new ServerMessagePacket(UTF8.GetBytes("Please input a value for all parameters!"));
OutputLog(client.clientData.clientNickname + " has tried to roll dice without the correct number of parameters! (" + command + ")");
}
client.TCPSend(serverMessagePacket5);
break;
case "ANNOUNCE":
//get full announcement message
int start = command.IndexOf(" ");
string msg = command.Substring(start + 1, command.Length - (start + 1));
//send announcement message to all clients and server logs
AnnouncementMessagePacket announcementMessagePacket = new AnnouncementMessagePacket(UTF8.GetBytes(msg));
TCPSendPacketToAll(announcementMessagePacket);
OutputLog(msg);
break;
default:
//send client chat message
chatMessagePacket = new ChatMessagePacket(UTF8.GetBytes(client.clientData.clientNickname + ": "), UTF8.GetBytes(command));
client.TCPSend(chatMessagePacket);
//send server reponse
serverMessagePacket = new ServerMessagePacket(UTF8.GetBytes("Sorry that is not a command! For a list of commands type '/help'."));
client.TCPSend(serverMessagePacket);
break;
}
}
catch (Exception e)
{
OutputLog("[Error] " + e.Message + e.StackTrace);
}
}
private void TCPProcessServerResponse()
{
Packet receivedPacket;
while ((receivedPacket = TCPRead()) != null)
{
try
{
switch (receivedPacket.EPacketType)
{
case PacketType.EMPTY:
EmptyPacket emptyPacket = (EmptyPacket)receivedPacket;
break;
case PacketType.CHATMESSAGE:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)receivedPacket;
//Write message to client console
Console.WriteLine(chatMessagePacket.Time + " " + UTF8.GetString(chatMessagePacket.OriginClient) + ": " + UTF8.GetString(chatMessagePacket.Message));
//Write message to client form
_clientForm.UpdateChatWindow(chatMessagePacket.Time + " " + UTF8.GetString(chatMessagePacket.OriginClient) + ": " + UTF8.GetString(chatMessagePacket.Message));
break;
case PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)receivedPacket;
//Write pm to client console
Console.WriteLine(privateMessagePacket.Time + " [PM] " + UTF8.GetString(privateMessagePacket.OriginClient) + " -> " + UTF8.GetString(privateMessagePacket.PrivateMessage));
//Write message to client form
_clientForm.UpdateChatWindow(privateMessagePacket.Time + " [PM] " + UTF8.GetString(privateMessagePacket.OriginClient) + " -> " + UTF8.GetString(privateMessagePacket.PrivateMessage));
break;
case PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessagePacket = (ServerMessagePacket)receivedPacket;
//Write server response to client console
Console.WriteLine(serverMessagePacket.Time + " [Server] -> " + UTF8.GetString(serverMessagePacket.Message));
//Write server response to client form
_clientForm.UpdateChatWindow(serverMessagePacket.Time + " [Server] -> " + UTF8.GetString(serverMessagePacket.Message));
break;
case PacketType.ANNOUNCEMESSAGE:
AnnouncementMessagePacket announcementMessagePacket = (AnnouncementMessagePacket)receivedPacket;
//Write announcement to client console
Console.WriteLine(announcementMessagePacket.Time + " " + "[Announcement] -> " + UTF8.GetString(announcementMessagePacket.Message));
//Write announcement to client form
_clientForm.UpdateChatWindow(announcementMessagePacket.Time + " " + "[Announcement] -> " + UTF8.GetString(announcementMessagePacket.Message));
break;
case PacketType.SERVERKEY:
ServerKeyPacket serverKeyPacket = (ServerKeyPacket)receivedPacket;
_serverKey = serverKeyPacket.ServerKey;
successfulLogin = serverKeyPacket.Successful;
Console.WriteLine("Server Key Packet Received!");
break;
case PacketType.CLIENTLIST:
ClientListPacket clientListPacket = (ClientListPacket)receivedPacket;
_clientForm.RefreshClientList(clientListPacket.ClientList, clientListPacket.ClientIPS);
break;
}
}
catch (SocketException e)
{
Console.WriteLine("[Error] " + e.Message + e.StackTrace);
break;
}
}
}
private static void HandlePacket(Client client, Packet packet)
{
Console.WriteLine("Transferred to handler");
switch (packet.packettype)
{
case PacketType.USER:
client.clientNickname = ((UserPacket)packet).nickname;
client.clientStatus = ((UserPacket)packet).status;
userList();
break;
case PacketType.CHATMESSAGE:
string message = ((ChatMessagePacket)packet).message;
ChatMessagePacket chatMessage = new ChatMessagePacket("[" + client.clientNickname + "]: " + message);
foreach (Client c in clients)
{
c.send(chatMessage);
}
break;
case PacketType.SERVER_MESSAGE:
string servermessage = ((ServerMessagePacket)packet).message;
ServerMessagePacket serverMessage = new ServerMessagePacket(serverPrefix + servermessage);
foreach (Client c in clients)
{
c.send(serverMessage);
}
break;
case PacketType.POKE:
Console.WriteLine("got poker");
string poker = ((PokePacket)packet).poker;
string pokee = ((PokePacket)packet).pokee;
foreach (Client c in clients)
{
if (c.clientNickname == pokee)
{
c.send(new PokePacket(poker, pokee));
Console.WriteLine(c.clientNickname);
}
}
break;
case PacketType.COMMAND:
switch (((CommandPacket)packet).command)
{
case "!roll":
Random rnd = new Random();
int roll = rnd.Next(1, 99);
ServerMessagePacket rollres = new ServerMessagePacket(serverPrefix + client.clientNickname + " rolled: " + roll);
{
foreach (Client c in clients)
{
c.send(rollres);
}
}
break;
default:
break;
}
break;
case PacketType.DISCONNECT:
foreach (Client c in clients)
{
Console.WriteLine("Sending");
c.send(new ServerMessagePacket(serverPrefix + client.clientNickname + " has left the server."));
}
break;
}
}
private void TcpProcessServerPacket()
{
Packet packet = new Packet();
while (_net.IsTcpConnected)
{
packet = _net.TcpReadPacket();
Debug("TcpProcessServerPacket: packet = " + packet);
if (packet != null)
{
switch (packet._packetType)
{
case Packet.PacketType.EMPTY:
/* do nothing */
break;
case Packet.PacketType.CLIENTNAME:
ClientNamePacket namePacket = (ClientNamePacket)packet;
_win.name = namePacket._name;
_nick = namePacket._name;
break;
case Packet.PacketType.CHATMESSAGE:
ChatMessagePacket chatPacket = (ChatMessagePacket)packet;
_win.UpdateChat(chatPacket._message);
break;
case Packet.PacketType.PRIVATEMESSAGE:
PrivateMessagePacket privPacket = (PrivateMessagePacket)packet;
_win.UpdateChat(privPacket._packetSrc + ": " + privPacket._message);
break;
case Packet.PacketType.LOGIN:
Console.WriteLine("Logged in to server.");
_net.TcpFinishLogin((LoginPacket)packet);
break;
case Packet.PacketType.SECUREMESSAGE:
SecurePacket safePacket = (SecurePacket)packet;
_win.UpdateChat(
"Secure Message Received [" + safePacket._packetSrc + "]: " +
_net.DecryptString(safePacket._data)
);
break;
case Packet.PacketType.ENDSESSION:
Console.WriteLine("Disconnecting from server.");
_net.Close();
break;
case Packet.PacketType.JOINGAME:
_win.StartGame(this);
break;
case Packet.PacketType.USERLIST:
UserListPacket userList = (UserListPacket)packet;
_win.UserList = userList._users;
break;
case Packet.PacketType.LEAVEGAME:
LeaveGamePacket leaveGame = (LeaveGamePacket)packet;
if (leaveGame._wasForced)
{
_win.StopGame();
}
break;
case Packet.PacketType.SERVERMESSAGE:
ServerMessagePacket serverMessage = (ServerMessagePacket)packet;
_win.UpdateChat(serverMessage._messageSent);
break;
}
}
}
}
