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.LOGIN:
LoginPacket loginPacket = (LoginPacket)receivedPacket;
_clients[index].clientData.posX = loginPacket.SpriteX;
_clients[index].clientData.posY = loginPacket.SpriteY;
_clients[index].clientData.playerIndex = (_clients.Count - 1);
//confirm connection to joining player
JoinConfirmationPacket joinConfirmationPacket = new JoinConfirmationPacket((_clients.Count - 1), GetAllPlayerXValues(), GetAllPlayerYValues());
_clients[index].TCPSend(joinConfirmationPacket);
PlayerJoinPacket playerJoinPacket = new PlayerJoinPacket(_clients.Count - 1, loginPacket.SpriteX, loginPacket.SpriteY);
Console.WriteLine(_clients.Count);
TCPSendPacketToAll(playerJoinPacket);
Console.WriteLine("PACKETS SENT");
break;
case PacketType.DISCONNECT:
DisconnectPacket disconnectRequestPacket = (DisconnectPacket)receivedPacket;
break;
}
}
catch (Exception e)
{
Console.WriteLine("[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)
{
Console.WriteLine("[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.PLAYERJOIN:
PlayerJoinPacket playerJoinPacket = (PlayerJoinPacket)receivedPacket;
if (_game.localServerIndex != playerJoinPacket.ExistingPlayers)
{
_game.InitialiseNewPlayer(playerJoinPacket.X, playerJoinPacket.Y);
}
break;
case PacketType.JOINCONFIRMATION:
JoinConfirmationPacket joinConfirmationPacket = (JoinConfirmationPacket)receivedPacket;
_game.localServerIndex = joinConfirmationPacket.ServerIndex;
if (joinConfirmationPacket.ServerIndex > 0)
{
_game.LoadExistingPlayers(joinConfirmationPacket.ServerIndex, joinConfirmationPacket.XValues, joinConfirmationPacket.YValues);
}
_game.InitialiseNewPlayer(0.0f, 0.0f);
break;
case PacketType.PLAYERPOSITION:
PlayerPositionPacket playerPositionPacket = (PlayerPositionPacket)receivedPacket;
_game.ChangePlayerPosition(playerPositionPacket.PlayerIndex, playerPositionPacket.X, playerPositionPacket.Y);
break;
}
}
catch (SocketException e)
{
Debug.WriteLine("[Error] " + e.Message + e.StackTrace);
break;
}
}
}
// Reads the serialized packets coming from the client
public Packet Read()
{
int numberOfBytes;
lock (m_readLock)
{
if ((numberOfBytes = m_reader.ReadInt32()) != -1)
{
byte[] buffer = m_reader.ReadBytes(numberOfBytes);
MemoryStream memStream = new MemoryStream(buffer);
return(m_formatter.Deserialize(memStream) as Packet);
}
else
{
EmptyPacket packet = new EmptyPacket("Error: Empty Packet detected");
return(packet);
}
}
}
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 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;
}
}
}
