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