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