private void UdpProcessServerResponse()
{
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
while (true)
{
byte[] bytes = udpClient.Receive(ref endPoint);
MemoryStream memoryStream = new MemoryStream(bytes);
Packet packet = formatter.Deserialize(memoryStream) as Packet;
switch (packet.packetType)
{
case PacketType.CHAT_MESSAGE:
ChatMessagePacket chatPacket = (ChatMessagePacket)packet;
clientForm.UpdateChatWindow(chatPacket.message, "left", Color.Black, Color.Gold);
break;
case PacketType.PRIVATE_MESSAGE:
PrivateMessagePacket privatePacket = (PrivateMessagePacket)packet;
clientForm.UpdateChatWindow(privatePacket.message, "left", Color.Black, Color.LightPink);
break;
}
}
}
catch (SocketException e)
{
Console.WriteLine("Client UDP Read Method Exception: " + e.Message);
}
}
void TcpRespondTo(PrivateMessagePacket privPacket, Client source)
{
foreach (KeyValuePair <int, Client> pair in _clients)
{
if (pair.Value._name == privPacket._target)
{
privPacket._message = source._name + ": " + privPacket._message;
pair.Value.TcpSend(privPacket);
}
}
}
//sends private chat packet
public void SendPrivateMessage(string message, string username, int receiver)
{
PrivateMessagePacket messagePacket = new PrivateMessagePacket(username, message, receiver);
MemoryStream msgStream = new MemoryStream();
formatter.Serialize(msgStream, messagePacket);
byte[] buffer = msgStream.GetBuffer();
writer.Write(buffer.Length);
writer.Write(buffer);
writer.Flush();
}
//processes server responce
private void ProcessServerResponse()
{
int numberOfBytes;
//if connected to server
while (isConnected == true)
{
//read data from server and deserialize
if ((numberOfBytes = reader.ReadInt32()) != 0)
{
byte[] buffer = reader.ReadBytes(numberOfBytes);
MemoryStream _stream = new MemoryStream(buffer);
Packet packet = formatter.Deserialize(_stream) as Packet;
//if packet type is...
switch (packet.mPacketType)
{
//send message to all
case PacketType.chatMessage:
ChatMessagePacket chatPacket = (ChatMessagePacket)packet;
mClientForm.UpdateChatWindow(chatPacket.mSender + ": " + chatPacket.mMessage);
break;
//send disconnect message to all
case PacketType.disconnectMessage:
DisconnectMessagePacket disconnectPacket = (DisconnectMessagePacket)packet;
mClientForm.UpdateChatWindow(disconnectPacket.mSender + ": has disconnected.");
break;
//send connect message to all
case PacketType.connectMessage:
ConnectMessagePacket connectPacket = (ConnectMessagePacket)packet;
mClientForm.UpdateChatWindow(connectPacket.mSender + ": has connected.");
break;
//send private message to user
case PacketType.privateMessage:
PrivateMessagePacket privateMessagePacket = (PrivateMessagePacket)packet;
mClientForm.UpdateChatWindow(privateMessagePacket.mSender + "(" + privateMessagePacket.mReceiver + ")" + " Wispers: " + privateMessagePacket.mMessage);
break;
}
}
}
reader.Close();
writer.Close();
tcpClient.Close();
}
private void ProcessServerResponse()
{
int byteNum;
try
{
while (connected)
{
if ((byteNum = reader.ReadInt32()) != 0)
{
byte[] buffer = reader.ReadBytes(byteNum);
MemoryStream memstream = new MemoryStream(buffer);
Packet packet = formatter.Deserialize(memstream) as Packet;
switch (packet.packetType)
{
case PacketType.ChatMessage:
ChatMessagePacket chatPacket = (ChatMessagePacket)packet;
clientForm.UpdateChatWindow(chatPacket.message);
break;
case PacketType.UserListPacket:
UserListPacket listPacket = (UserListPacket)packet;
clientForm.UserListBox_Edit(listPacket.userList);
break;
case PacketType.PrivateMessage:
PrivateMessagePacket msgPacket = (PrivateMessagePacket)packet;
clientForm.OpenPrivateMessage(msgPacket.sender, msgPacket.message);
break;
}
}
else
{
break;
}
}
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
}
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);
}
}
}
private void UdpListen()
{
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
while (true)
{
byte[] bytes = udpListener.Receive(ref endPoint);
MemoryStream memoryStream = new MemoryStream(bytes);
Packet packet = new BinaryFormatter().Deserialize(memoryStream) as Packet;
foreach (KeyValuePair <int, Client> c in clients)
{
if (endPoint.ToString() != c.Value.endPoint.ToString())
{
switch (packet.packetType)
{
case PacketType.CHAT_MESSAGE:
ChatMessagePacket inChatPacket = (ChatMessagePacket)packet;
ChatMessagePacket outChatPacket = new ChatMessagePacket(inChatPacket.message);
UdpSend(c.Value, outChatPacket);
break;
case PacketType.PRIVATE_MESSAGE:
PrivateMessagePacket inPrivatePacket = (PrivateMessagePacket)packet;
PrivateMessagePacket outPrivatePacket = new PrivateMessagePacket(inPrivatePacket.message, inPrivatePacket.name);
if (c.Value.name == outPrivatePacket.name)
{
UdpSend(c.Value, outPrivatePacket);
}
break;
}
}
}
}
}
catch (SocketException e)
{
Console.WriteLine("Server UDP Read Method Exception: " + e.Message);
}
}
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);
}
//client method sends data from server program to client program
private void ClientMethod(Client client)
{
Packet packet;
try
{
//while client is reading data
while ((packet = client.Read()) != null)
{
switch (packet.mPacketType)
{
//send message to everyone
case PacketType.chatMessage:
ChatMessagePacket chatMessagePacket = (ChatMessagePacket)packet;
foreach (Client onlineClient in clients.Values)
{
onlineClient.Send(packet);
}
break;
//send disconnect message to everyone
case PacketType.disconnectMessage:
DisconnectMessagePacket disconnectPacket = (DisconnectMessagePacket)packet;
foreach (Client onlineClient in clients.Values)
{
onlineClient.Send(packet);
}
break;
//send connect message
case PacketType.connectMessage:
ConnectMessagePacket connectMessage = (ConnectMessagePacket)packet;
foreach (Client onlineClient in clients.Values)
{
onlineClient.Send(packet);
}
break;
//send private message to one user
case PacketType.privateMessage:
PrivateMessagePacket privateMessage = (PrivateMessagePacket)packet;
for (int i = 0; i < clients.Count(); i++)
{
if (i == privateMessage.mReceiver)
{
clients[i].Send(packet);
}
}
break;
default:
break;
}
}
}
//if try catch fails send error message
catch (Exception e)
{
Console.WriteLine("Error:" + e.Message);
}
//close client and remove from concurrent bag
finally
{
for (int i = 0; i < clients.Count(); i++)
{
//clients[i].Close();
clients.TryRemove(i, out client);
}
}
}
private void ClientMethod(int index)
{
try
{
Packet receivedMessage;
while ((receivedMessage = clients[index].Read()) != null)
{
switch (receivedMessage.packetType)
{
case PacketType.ChatMessage:
ChatMessagePacket chatPacket = (ChatMessagePacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (cli.Value != clients[index])
{
cli.Value.Send(chatPacket);
}
}
break;
case PacketType.NewName:
NewNamePacket namePacket = (NewNamePacket)receivedMessage;
try
{
clients[index].name = namePacket.newName;
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
break;
}
SendClientList();
break;
case PacketType.Connect:
ConnectPacket connectPacket = (ConnectPacket)receivedMessage;
clients[index].isGame = false;
clients[index].name = connectPacket.userName;
SendClientList();
break;
case PacketType.Disconnect:
break;
case PacketType.PrivateMessage:
PrivateMessagePacket msgPacket = (PrivateMessagePacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (cli.Value.name == msgPacket.receiver)
{
cli.Value.Send(msgPacket);
}
}
break;
case PacketType.GameConnect:
GameConnectPacket gameConnectPacket = (GameConnectPacket)receivedMessage;
clients[index].isGame = true;
clients[index].ID = gameConnectPacket.ID;
clients[index].connectedPlayers = gameConnectPacket.connectedPlayers;
if (clients[index].connectedPlayers.Count >= 2)
{
break;
}
foreach (KeyValuePair <int, Client> cli in clients)
{
if (cli.Value.isGame)
{
if (cli.Value.connectedPlayers.Count < 2)
{
if (cli.Value.ID != clients[index].ID)
{
cli.Value.connectedPlayers.Add(gameConnectPacket.ID);
clients[index].connectedPlayers.Add(cli.Value.ID);
cli.Value.Send(new GameConnectPacket(gameConnectPacket.ID, cli.Value.connectedPlayers, GameConnectPacket.PlayerType.Chooser));
clients[index].Send(new GameConnectPacket(gameConnectPacket.ID, clients[index].connectedPlayers, GameConnectPacket.PlayerType.Guesser));
break; //break out of foreach so only connect to one other player
}
}
}
}
break;
case PacketType.GameDisconnect:
GameDisconnectPacket gameDisconnectPacket = (GameDisconnectPacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (clients[index].connectedPlayers.Contains(cli.Value.ID))
{
if (cli.Value.ID != clients[index].ID)
{
cli.Value.Send(gameDisconnectPacket);
break; //send to the other player, not to the player that sent the packet
}
}
}
break;
case PacketType.GameResult:
GameResultPacket resultPacket = (GameResultPacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (clients[index].connectedPlayers.Contains(cli.Value.ID))
{
cli.Value.Send(resultPacket);
}
}
break;
case PacketType.GameUpdateDisplayedWord:
GameUpdateWordPacket updateWordPacket = (GameUpdateWordPacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (clients[index].connectedPlayers.Contains(cli.Value.ID))
{
cli.Value.Send(updateWordPacket);
}
}
break;
case PacketType.GameUpdateHangmanState:
GameUpdateHangmanPacket updateHangmanPacket = (GameUpdateHangmanPacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (clients[index].connectedPlayers.Contains(cli.Value.ID))
{
cli.Value.Send(updateHangmanPacket);
}
}
break;
case PacketType.GameSetWord:
GameSetWordPacket setWordPacket = (GameSetWordPacket)receivedMessage;
foreach (KeyValuePair <int, Client> cli in clients)
{
if (clients[index].connectedPlayers.Contains(cli.Value.ID))
{
cli.Value.Send(setWordPacket);
}
}
break;
default:
Console.WriteLine("Received packet of type " + receivedMessage.packetType);
break;
}
}
}
catch (Exception e)
{
Console.WriteLine("Exception: " + e.Message);
}
finally
{
clients[index].Close();
clients.TryRemove(index, out Client c);
SendClientList();
}
}
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 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;
}
}
}
}
public void SendPrivateMessage(string sender, string receiver, string message)
{
PrivateMessagePacket packet = new PrivateMessagePacket(sender + "#" + ID, receiver, message);
SendPacket(packet);
}
