public void OnDisconnect()
{
ClientListUpdate.Invoke(new List <CharacterData>());
m_initState.Init(false);
m_currentState = m_initState;
m_TCPClient.Unsubscribe(this);
#if DEBUG_LOG
Debug.Log("Lobby : lost connection to game server. Trying to reconnect...");
#endif // DEBUG_LOG
}
public void ReceivePacket(tcp.TCPToolkit.Packet packet)
{
ServerStartsMessage ready = common.serialization.IConvertible.CreateFromBytes <ServerStartsMessage>(packet.Data.ArraySegment());
if (ready != null)
{
#if DEBUG_LOG
Debug.Log("Received server start message.");
#endif // DEBUG_LOG
m_serverSentSignal = true;
return;
}
// loads other players in lobby, receives message from server indicating a new player joined
CharacterListMessage clientList = common.serialization.IConvertible.CreateFromBytes <CharacterListMessage>(packet.Data.ArraySegment());
if (clientList != null)
{
Debug.Log("Received " + clientList.PlayerCharacters.Value.Count + " characters from server");
foreach (common.serialization.types.String id in clientList.PlayerCharacters.Value.Values)
{
Debug.Log("Fetching character " + id.Value + " from microservice");
// fetch character data from microservice
string strID = id.Value;
m_characterService.GetCharacter(strID, (CharacterData character) =>
{
Debug.Log("Got character from " + character.PlayerID + " : " + character.Name);
m_clientCharacters[character.PlayerID.GetHashCode()] = character;
ClientListUpdate.Invoke(new List <CharacterData>(m_clientCharacters.Values));
});
}
return;
}
System.Diagnostics.Stopwatch watch = new System.Diagnostics.Stopwatch();
watch.Start();
ServerInitMessage start = common.serialization.IConvertible.CreateFromBytes <ServerInitMessage>(packet.Data.ArraySegment());
watch.Stop();
if (start != null)
{
#if DEBUG_LOG
Debug.Log("Time elapsed for world deserialization : " + watch.ElapsedMilliseconds + " ms");
#endif // DEBUG_LOG
m_awaitedInitMessage = start;
return;
}
}
private void ProcessServerResponce()
{
Console.Write(">>>");
Packet packet;
while ((packet = Read()) != null)
{
switch (packet.m_packetType)
{
case (PacketType.CHATMESSAGE):
{
ChatMessagePacket chatMessage = (ChatMessagePacket)packet;
clientForm.UpdateChatWindow(chatMessage.m_message);
break;
}
case (PacketType.CHATLOG):
{
ChatLog chatLog = (ChatLog)packet;
clientForm.UpdateChatWindow(chatLog.m_ChatLog);
break;
}
case (PacketType.CLIENTLISTUPDATE):
{
ClientListUpdate clientList = (ClientListUpdate)packet;
//clientForm.UpdateClientList(clientList.m_clientName);
break;
}
case (PacketType.EXIT):
{
ExitPacket exitPacket = (ExitPacket)packet;
Console.WriteLine(exitPacket.m_message);
break;
}
default:
{
break;
}
}
}
}
private void ConnectButton_Click(object sender, EventArgs e)
{
if (UsernameInput.Text.Length > 2)
{
if (ConnectButton.Text == "Connect")
{
ConnectButton.Text = "Disconnect";
UsernameInput.Enabled = false;
ClientList.Enabled = true;
SubmitButton.Enabled = true;
InputField.Enabled = true;
ChatMessagePacket connectBroadcast = new ChatMessagePacket("User: "******" has connected", m_client.ID);
m_client.SendMessage(connectBroadcast);
m_client.Name = UsernameInput.Text;
UsernameInput.Clear();
//MessageWindow.AppendText("You have successfully connected with the username " + m_client.Name + ".\n");
ClientListUpdate listUpdate = new ClientListUpdate(m_client.Name, m_client.ID);;
m_client.SendMessage(listUpdate);
//ClientList.Items.Add(m_client.Name);
Console.WriteLine(connectBroadcast.m_message);
}
}
else
{
if (ConnectButton.Text == "Disconnect")
{
ConnectButton.Text = "Connect";
UsernameInput.Enabled = true;
ClientList.Enabled = false;
SubmitButton.Enabled = false;
InputField.Enabled = false;
ChatMessagePacket disconnectBroadcast = new ChatMessagePacket("User: "******" has disconnected.", m_client.ID);
m_client.SendMessage(disconnectBroadcast);
MessageWindow.AppendText("You have successfully Disconnected.\n");
Console.WriteLine(disconnectBroadcast.m_message);
}
}
}
public void OnClientDisconnect(string clientID, Socket handler, ClientListUpdate clientListUpdateHandler)
{
//separate disconnect function as the functionality for handling a disconnect is the same
//even if the client crashes/is forcibly closed or even if it closes gracefully
//(by sending a ClientQuit packet)
lock (_messsageQueuesLocker)
{
ClientListUpdateEvent -= clientListUpdateHandler;
connectedClients.Remove(clientID.ToString());
disconnectedClients.Add(clientID.ToString());
}
Message clientDisconnectedListMessage = new Message
{
ReceiverClientID = clientID,
MessageType = MessageType.ClientDisconnectedList,
MessageBody = string.Join(",", disconnectedClients.ToArray())
};
Message im = new Message
{
SenderClientID = null,
ReceiverClientID = null,
MessageType = MessageType.ClientQuitUpdate,
MessageBody = clientID.ToString(),
Broadcast = false
};
handler.Shutdown(SocketShutdown.Both);
handler.Close();
foreach (Socket s in connectedClients.Values)
{
SendPacket(clientDisconnectedListMessage, s);
SendPacket(im, s);
}
ClientListUpdateEvent?.Invoke();
}
// Logic to determine what to do with incoming packets
private void ClientMethod(int index, ServerClient client)
{
try
{
//m_Clients[index].SetClientData(index, "User" + index.ToString());
Packet packet;
ServerClient m_client = client;
while ((packet = m_client.Read()) != null)
{
Console.WriteLine("ServerClient >>> Message Recieved");
switch (packet.m_packetType)
{
case (PacketType.CHATMESSAGE):
{
ChatMessagePacket chatPacket = (ChatMessagePacket)packet;
for (int i = 0; i < m_Clients.Count; i++)
{
m_Clients[i].Send(chatPacket);
}
Console.WriteLine("Server broadcasted >>> ChatMessagePacket from Client " + index);
break;
}
case (PacketType.PRIVATEMESSAGE):
{
PrivateChatMessagePacket privateMessage = (PrivateChatMessagePacket)packet;
m_Clients[privateMessage.m_clientID].Send(privateMessage);
m_Clients[privateMessage.m_receiverID].Send(privateMessage);
Console.WriteLine("Server Recieved >>> Private Message from Client " + privateMessage.m_clientID + " To Client " + privateMessage.m_receiverID);
break;
}
case (PacketType.CLIENTNAME):
{
m_Clients[index].SetClientData(index, m_Clients[index].m_clientData.Name);
Console.WriteLine("Client name: " + m_Clients[index].m_clientData.Name + "Saved to server");
break;
}
case (PacketType.CHATLOG):
{
ChatLog chatLog = (ChatLog)packet;
m_chatLog = chatLog.m_ChatLog;
break;
}
case (PacketType.CLIENTLISTUPDATE):
{
ClientListUpdate clientList = (ClientListUpdate)packet;
for (int i = 0; i < m_Clients.Count; i++)
{
m_Clients[i].Send(clientList);
}
break;
}
case (PacketType.EMPTYPACKET):
{
break;
}
case (PacketType.EXIT):
{
m_client.Send(packet);
break;
}
default:
{
break;
}
}
}
m_client.Close();
ServerClient c;
m_Clients.TryRemove(index, out c);
}
catch (Exception e)
{
Console.WriteLine("Error occured" + e.Message);
}
}
public void AcceptConnection(Socket handler)
{
string clientID = null;
byte[] bytes = new byte[1024];
Message clientIDMessage = new Message();
Message clientListMessage = new Message();
Message clientDisconnectedListMessage = new Message();
MessageParser parser = new MessageParser();
//thread-specific anonymous function to handle a change in clientList
//storing it in a variable so we can unsubscribe from it later
ClientListUpdate ClientListUpdateEventHandler = () =>
{
clientListMessage.ReceiverClientID = currentClient.ToString();
clientListMessage.MessageType = MessageType.ClientList;
clientListMessage.MessageBody = string.Join(",", connectedClients.Keys.ToArray());
SendPacket(clientListMessage, handler);
};;
while (true && handler.Connected)
{
try
{
int bytesReceived = handler.Receive(bytes);
Queue <byte[]> incoming = parser.ReceiverParser(bytes, bytesReceived);
foreach (byte[] data in incoming)
{
if (data != null)
{
Message im = Serializer <Message> .Deserialize(data);
if (im.MessageType == MessageType.ClientJoin)
{
clientID = im.SenderClientID;
lock (_messsageQueuesLocker)
{
connectedClients.Add(clientID, handler);
if (disconnectedClients.Contains(clientID.ToString()))
{
disconnectedClients.Remove(clientID.ToString());
}
}
//subscribing the client to the server for update in clientList
ClientListUpdateEvent += ClientListUpdateEventHandler;
Log.Information("[Client] Client {0} connected. IP: {1};", clientID, handler.RemoteEndPoint.ToString());
clientIDMessage.ReceiverClientID = clientID;
clientIDMessage.MessageType = MessageType.ClientID;
clientIDMessage.MessageBody = clientID;
SendPacket(clientIDMessage, handler);
//sending a list of previously connected (currently disconnected) clients
clientDisconnectedListMessage.ReceiverClientID = clientID;
clientDisconnectedListMessage.MessageType = MessageType.ClientDisconnectedList;
clientDisconnectedListMessage.MessageBody = string.Join(",", disconnectedClients.ToArray());
SendPacket(clientDisconnectedListMessage, handler);
//raising ClientListUpdateEvent since clientList has changed
ClientListUpdateEvent?.Invoke();
Message joinUpdateMessage = new Message
{
SenderClientID = null,
ReceiverClientID = null,
MessageType = MessageType.ClientJoinUpdate,
MessageBody = clientID.ToString(),
Broadcast = false
};
//lets all the clients know that another client has joined the server
foreach (Socket s in connectedClients.Values)
{
if (!s.Equals(handler))
{
SendPacket(joinUpdateMessage, s);
}
}
currentClient++;
}
else if (im.MessageType == MessageType.ClientQuit)
{
Log.Information("[ClientDisconnected] Client {0} has disconnected (gracefully).", clientID);
OnClientDisconnect(clientID, handler, ClientListUpdateEventHandler);
break;
}
else if (im.MessageType == MessageType.ClientMessage)
{
if (im.Broadcast == true)
{
Log.Information("[Broadcast] Client: {0} -> All clients, Message: {1}", im.SenderClientID, im.MessageBody);
foreach (Socket s in connectedClients.Values)
{
if (!s.Equals(handler))
{
SendPacket(im, s);
}
}
}
else if (connectedClients.ContainsKey(im.ReceiverClientID))
{
Log.Information("[ClientMessage] Client: {0} -> Client: {1}, Message: {2}", im.SenderClientID, im.ReceiverClientID,
im.MessageBody);
Socket receiver = connectedClients[im.ReceiverClientID];
SendPacket(im, receiver);
}
else if (disconnectedClients.Contains(im.ReceiverClientID))
{
Log.Information("[ClientMessageFailure] Client: {0} -> Client: {1}, Message: {2}", im.SenderClientID, im.ReceiverClientID,
im.MessageBody);
lock (_messsageQueuesLocker)
{
//adding message to queue for clients
if (!messageQueues.ContainsKey(im.ReceiverClientID))
{
messageQueues.Add(im.ReceiverClientID, new Queue <TimestampedMessage>());
}
messageQueues[im.ReceiverClientID].Enqueue(new TimestampedMessage
{
receivedAt = DateTime.Now,
message = new Message(im)
});
}
Log.Information("Message queue for client: {0}, length: {1}", im.ReceiverClientID, messageQueues[im.ReceiverClientID].Count);
im.MessageType = MessageType.ClientMessageFailure;
im.MessageBody = messageFailureErrorCodes[2];
SendPacket(im, handler);
}
else
{
Log.Information("[ClientMessageIncorrectID] Client: {0} -> Client: {1}, Message: {2}", im.SenderClientID, im.ReceiverClientID,
im.MessageBody);
im.MessageType = MessageType.ClientMessageFailure;
im.MessageBody = messageFailureErrorCodes[1];
SendPacket(im, handler);
}
}
}
}
}
catch (SerializationException se)
{
Log.Error("SerializationException (Client probably went down or disconnected): {0}", se.ToString());
}
catch (SocketException)
{
Log.Information("[ClientDisconnected] Client {0} has disconnected (forcibly closed).", clientID);
OnClientDisconnect(clientID, handler, ClientListUpdateEventHandler);
break;
}
}
}
