public void ServerUdpClientSend() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- UDP_Config config; config.address = "127.0.0.1"; config.port = 4486; IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 4485); ServerListenerUDP listener = new ServerListenerUDP(config); DotNetserialization serializer = new DotNetserialization(); ServerLibrary.UDPClient client = new ServerLibrary.UDPClient("Tester"); client.AddSerializer(serializer); client.AddEndPoint(endPoint); client.AddListener(listener); ChatMessagePacket packet = new ChatMessagePacket("This is a test", "Tester"); //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- client.Send(packet); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- }
protected override void OnHandle(IPacket packet, NetState netState, ServerWorldState worldState) { ChatMessagePacket packetToHandle = (ChatMessagePacket)packet; ServerCharacter serverCharacter = (ServerCharacter)worldState.GetCharacter(netState.WorldId); if (serverCharacter != null) { string ghostText = this.GhostText(packetToHandle.Message); serverCharacter.SentMessage(); foreach (int mapCharacterId in worldState.Characters) { ServerCharacter characterToUpdate = (ServerCharacter)worldState.GetCharacter(mapCharacterId); NetState clientSendTo = characterToUpdate.Owner; ChatMessagePacket packetToSend; if (serverCharacter.IsDead && !characterToUpdate.IsDead) { packetToSend = new ChatMessagePacket(serverCharacter.Id, ghostText); } else { packetToSend = new ChatMessagePacket(serverCharacter.Id, packetToHandle.Message); } clientSendTo.Send(packetToSend); } } }
static void HandlePacket(ClientClass client, Packet packet) { ClientClass currentClient = client; switch (packet.type) { case PacketType.CHATMESSAGE: string message = ((ChatMessagePacket)packet)._message; if (message != "/exit") { ChatMessagePacket chatmessagepacket = new ChatMessagePacket(message); currentClient.Send(chatmessagepacket); } else { string exitAnnounce = "[user has disconnected]"; ChatMessagePacket chatmessagepacket = new ChatMessagePacket(exitAnnounce); currentClient.Send(chatmessagepacket); } break; } }
/// <summary> /// Sends message to anybody /// </summary> private void TrySendMessage() { if (Input.GetKeyDown(KeyCode.Return)) { if (!string.IsNullOrEmpty(messageInputField.text)) { if (string.IsNullOrEmpty(username)) { Mst.Events.Invoke(MstEventKeys.showOkDialogBox, new OkDialogBoxEventMessage("Username cannot be empty! Set username in UsernamePickView and try again")); return; } var message = new ChatMessagePacket() { Receiver = defaultChannelName, Sender = username, Message = messageInputField.text, MessageType = ChatMessageType.ChannelMessage }; messageInputField.text = string.Empty; Mst.Client.Chat.SendMessage(message, (isSuccess, error) => { if (!isSuccess) { Mst.Events.Invoke(MstEventKeys.showOkDialogBox, new OkDialogBoxEventMessage(error)); return; } }); } } }
/*public void Run() * { * string userInput; * * ProcessServerResponse(); * * while ((userInput = Console.ReadLine()) != null) * { * writer.WriteLine(userInput); * writer.Flush(); * * ProcessServerResponse(); * * if (userInput == "exit") * { * break; * } * } * * tcpClient.Close(); * }*/ void ProcessServerResponse() { //string response; //Console.Write("Server says: " + reader.ReadLine()); //Console.Write(); int noOfIncomingBytes = 0; try { while ((noOfIncomingBytes = reader.ReadInt32()) != 0) { byte[] bites = reader.ReadBytes(noOfIncomingBytes); MemoryStream byteStream = new MemoryStream(bites); Packet packet = formatter.Deserialize(byteStream) as Packet; ChatMessagePacket messageRead = HandlePacket(packet) as ChatMessagePacket; var this_read = Task.Run(() => UpdateChatWindow(messageRead._message)); } } catch (Exception e) { Console.WriteLine(e.Message); } }
private void OnMessageReceived(ChatMessagePacket message, int connectionid) { var messageGO = Instantiate(MessagePrefab, MessagesRoot, false); messageGO.GetComponent <Text>().text = $"[{DateTime.Now:t}] ({message.Sender}) : {message.Data}"; messageGO.SetActive(true); }
public void ProtobufSerializeChatPacket() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- ProtoBufSerializer serializer = new ProtoBufSerializer(); ChatMessagePacket packet = new ChatMessagePacket("This is a test", "Tester"); byte[] data; byte[] expectedData = { 162, 6, 16, 26, 14, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 115, 116, 8, 2, 18, 6, 84, 101, 115, 116, 101, 114 }; //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- data = serializer.Serialize(packet); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- Assert.IsNotNull(data); Assert.AreEqual(expectedData, data); }
private void HandleMessage(NetIncomingMessage msg) { PacketType type = (PacketType)msg.ReadByte(); switch (type) { case PacketType.ChatMessage: ChatMessagePacket chatPacket = new ChatMessagePacket(); chatPacket.Unpack(msg); ChatManager.Instance.addMessage(chatPacket.username, chatPacket.message); break; case PacketType.PlayerPosition: PlayerPositionPacket posPacket = new PlayerPositionPacket(); posPacket.Unpack(msg); ClientGameManager.Instance.HandleNewPlayerPosition(posPacket); break; case PacketType.Disconnect: DisconnectPacket disPacket = new DisconnectPacket(); disPacket.Unpack(msg); ClientGameManager.Instance.HandlePlayerDisconnect(disPacket.username); break; case PacketType.MobPosition: MobPositionPacket mpPacket = new MobPositionPacket(); mpPacket.Unpack(msg); ClientGameManager.Instance.HandleMobMovement(mpPacket); break; } }
private void XO_EndGame(char winner) { GamePacket packet = new GamePacket(""); ChatMessagePacket chatpacket = new ChatMessagePacket(""); if (winner == 'o') { packet.message = "win"; XO_Player1.Send(packet); packet.message = "lose"; XO_Player2.Send(packet); chatpacket.message = "Server - " + XO_Player1.GetName() + " won a game of Naughts & Crosses against " + XO_Player2.GetName(); SendToAll(chatpacket); } else if (winner == 'x') { packet.message = "win"; XO_Player2.Send(packet); packet.message = "lose"; XO_Player1.Send(packet); chatpacket.message = "Server - " + XO_Player2.GetName() + " won a game of Naughts & Crosses against " + XO_Player1.GetName(); SendToAll(chatpacket); } else if (winner == 'd') { packet.message = "draw"; XO_Player1.Send(packet); XO_Player2.Send(packet); chatpacket.message = "Server - " + XO_Player2.GetName() + " & " + XO_Player1.GetName() + " were tied in a game of Naughts & Crosses!"; SendToAll(chatpacket); } }
public void ProtobufDeserializeChatPacket() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- ProtoBufSerializer serializer = new ProtoBufSerializer(); ChatMessagePacket Expectedpacket = new ChatMessagePacket("This is a test", "Tester"); List <Packet> packet = new List <Packet>(); byte[] data = { 162, 6, 16, 26, 14, 84, 104, 105, 115, 32, 105, 115, 32, 97, 32, 116, 101, 115, 116, 8, 2, 18, 6, 84, 101, 115, 116, 101, 114 }; //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- packet.Add(serializer.Deserialize(data)); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- ChatMessagePacket output = (ChatMessagePacket)packet[0]; //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- Assert.IsNotNull(data); Assert.AreEqual(Expectedpacket.message, output.message); Assert.AreEqual(Expectedpacket.sender, output.sender); Assert.AreEqual(Expectedpacket.type, output.type); }
public void ClientConnectionUdpSend() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- UDP_Config config; config.address = "127.0.0.1"; config.port = 4522; DotNetserialization serializer = new DotNetserialization(); ClientLibrary.ClientListenerUDP listener = new ClientLibrary.ClientListenerUDP(config); ClientLibrary.ClientConnectionUDP connection = new ClientLibrary.ClientConnectionUDP("Test_Connection", "Tester"); connection.AddListener(listener); connection.AddSerializer(serializer); connection.Start(); ChatMessagePacket packet = new ChatMessagePacket("This is a test", "Tester"); //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- connection.Send(packet); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- }
public void SendUdpToClient() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- UDP_Config config; config.address = "127.0.0.1"; config.port = 4440; ServerLibrary.Server server = new ServerLibrary.Server(); ServerLibrary.ServerConnectionUDP connection = new ServerLibrary.ServerConnectionUDP("TesterUdpClient"); ServerListenerUDP listener = new ServerListenerUDP(config); connection.AddListener(listener); server.AddConnection(connection); server.Start(); ChatMessagePacket packet = new ChatMessagePacket("Hello", "Tester"); //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- server.SendPacketToClient(packet, "TesterUdpClient", "Bob"); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- }
void OnUdpDataReceived(ushort userPacketTypeIndex, uint senderID, Stream stream) { if (userPacketTypeIndex != (ushort)UserPacketType.ChatMessage) { return; } ChatMessagePacket chatMessagePacket = new ChatMessagePacket(); chatMessagePacket.Deserialize(stream); string senderDisplayName = chatMessagePacket.Payload.senderDisplayName; string message = chatMessagePacket.Payload.message; if (UdpNetworkManager.Instance.IsServer) { ChatMessagesManager.Instance.SendChatMessage(senderDisplayName, message, senderID, 0); } if (senderID != UdpNetworkManager.Instance.GetSenderID()) { chatText.text += ChatMessagesManager.Instance.FormatOuterDisplayName(senderDisplayName); chatText.text += ChatMessagesManager.Instance.FormatOuterMessage(message); } UpdateScrollRect(); }
private void SendText(string text, string color) { ChatMessagePacket message = new ChatMessagePacket(text, color); Console.WriteLine("Sent: " + message + "Color: " + color); Send(message); }
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); } }
public void sendMsg(String msg) { Console.WriteLine("Send Message"); ChatMessagePacket message = new ChatMessagePacket(msg); client.SendMessage(message); }
private void HandleChatMessage(ChatMessagePacket packet) { Player.Level.RelayBroadcast(new ChatMessagePacket() { Message = ChatHelper.EncodeChatMessage($"<{Player.Username}> {packet.Message}") }); }
public void TCPSendMessage(string message) { if (_tcpClient.Connected) { //checks if message is a command if (!message.StartsWith("/")) { //create message packet ChatMessagePacket packet = new ChatMessagePacket(EncryptString("Default"), EncryptString(message)); //serialize and send packet to all clients TCPSerialize(packet); } else { //creates command message packet CommandMessagePacket packet = new CommandMessagePacket(EncryptString(message)); //send message to client console Console.WriteLine(message); //serialize and send packet to all clients TCPSerialize(packet); } } }
private void UdpHandlePacket(IPEndPoint endPoint, Packet packet) { switch (packet.GetType()) { case packetType.EMPTY: Console.WriteLine("UDP - Empty Packet Recieved."); break; case packetType.CHATMESSAGE: break; case packetType.GAME: Console.WriteLine("UDP - Game Packet Recieved."); break; case packetType.NICKNAME: Console.WriteLine("UDP - Nickname Packet Recieved."); break; case packetType.NOTICE: Console.WriteLine("UDP - Notice Packet Recieved."); string notice = ((NoticePacket)packet).notice; ChatMessagePacket broadcast = new ChatMessagePacket("UDP Server - " + notice); UdpSend(endPoint, broadcast); break; } }
private void ClientMethod(object clientObj) { Client client = (Client)clientObj; //string receivedMessage = ""; NetworkStream stream = client.GetStream(); BinaryReader reader = client.GetReader(); BinaryWriter writer = client.GetWriter(); ChatMessagePacket message = new ChatMessagePacket("Server - Welcome! Set a nickname to continue."); client.Send(message); writer.Flush(); int noOfIncomingBytes; while ((noOfIncomingBytes = client.GetReader().ReadInt32()) != 0) { Byte[] bytes = reader.ReadBytes(noOfIncomingBytes); MemoryStream memoryStream = new MemoryStream(bytes); Packet packet = formatter.Deserialize(memoryStream) as Packet; HandlePacket(client, packet); //writer.Flush(); if (!client.IsConnected()) { break; } } }
public void ServerSendTcpToAll() { //--------------------------------------------------------------------- //Setup //--------------------------------------------------------------------- TCP_Config config; config.address = "127.0.0.1"; config.port = 4447; ServerLibrary.Server server = new ServerLibrary.Server(); ServerLibrary.ServerConnectionTCP connection = new ServerLibrary.ServerConnectionTCP("Tester"); ServerListenerTCP listener = new ServerListenerTCP(config); connection.AddListener(listener); server.AddConnection(connection); server.Start(); ChatMessagePacket packet = new ChatMessagePacket("Hello", "Tester"); //--------------------------------------------------------------------- //Run Test //--------------------------------------------------------------------- server.SendPacketToAll(packet, "Tester"); //--------------------------------------------------------------------- //Gather Output //--------------------------------------------------------------------- //--------------------------------------------------------------------- //Assert //--------------------------------------------------------------------- }
/// <summary> /// Pushes a confirmation that private message was successfully sent /// </summary> /// <param name="packet"></param> protected virtual void PushPrivateConfirmation(ChatMessagePacket packet) { var text = GetTextObject(); text.color = PrivateColor; text.text = string.Format("To [{0}]: {1}", packet.Receiver, packet.Message); }
private void AddMessageToChat(ChatMessagePacket msgPacket) { //Creates a new message and adds it to the list GameObject newMessageObject = Instantiate(m_messagePrefab, m_ViewContent); ChatMessage newCM = newMessageObject.GetComponent <ChatMessage>(); if (newCM == null) { Debug.LogError("Chat message prefab does not have a ChatMessage component, cannot add the recived message: " + msgPacket.Message); Destroy(newMessageObject); return; } //Init the message newCM.InitMessage(msgPacket.SenderID, msgPacket.Message); m_messagesList.AddLast(newCM); //If the chat history is full delete the last one if (m_messagesList.Count > m_maxChatHistoryLenght) { //Get the first message in the list, then remove it form the list and remvoe it from the ui LinkedListNode <ChatMessage> firstMessageNode = m_messagesList.First; ChatMessage cm = firstMessageNode.Value; m_messagesList.Remove(firstMessageNode); Destroy(cm.gameObject); } //Autoscroll Canvas.ForceUpdateCanvases(); StartCoroutine(CoroutineUtilities.DoOnNextFrame(() => { GetComponent <ScrollRect>().verticalScrollbar.value = 0.0f; })); }
private void SendButtonClick(object sender, EventArgs e) { string message = messageBox.Text; ChatMessagePacket packet = new ChatMessagePacket(message); Send(packet); messageBox.Text = ""; }
public void SendMessage(string sender, string message) { string msg = (sender + "#" + ID + ": " + message); clientForm.UpdateChatWindow(msg); ChatMessagePacket packet = new ChatMessagePacket(msg); SendPacket(packet); }
private void button1_Click(object sender, EventArgs e) { string message = enterText.Text; enterText.Text = string.Empty; ChatMessagePacket chatMessage = new ChatMessagePacket(message); Send(chatMessage); }
public ChatMessage(ChatMessagePacket pkt) { var chatComponent = ChatComponent.FromJson(pkt.Json); // use .ToString() for plaintext and components will output text with no formatting PlaintextMessage = chatComponent.ToString(); HtmlFormattedMessage = ChatComponent.GetFormattedString(chatComponent, null); }
// //Button control // private void SubmitButton_Click(object sender, EventArgs e) { ChatMessagePacket chatPacket = new ChatMessagePacket(m_client.Name + ": " + InputField.Text + "\n", m_client.ID); m_client.SendMessage(chatPacket); //MessageWindow.AppendText(chatPacket.m_message+"\n"); InputField.Clear(); Console.WriteLine("Message " + chatPacket.m_message + " Submitted"); }
private void ClientLoggedIn(Client client) { System.Threading.Thread.Sleep(1); JoinChatroom(client, _chatrooms[0]); // join the public chatroom ChatMessagePacket chatMessagePacket = new ChatMessagePacket(); chatMessagePacket.ChatRoomID = _chatrooms[0].ID; chatMessagePacket.Message = "You have joined to this chatroom..."; }
/// <summary> /// Handles chat message. /// Returns true, if message was handled /// If it returns false, message sender will receive a "Not Handled" response. /// </summary> protected virtual bool OnChatMessageReceived(ChatMessagePacket message, ChatUserExtension sender, IIncommingMessage rawMessage) { // Set a true sender message.Sender = sender.Username; switch (message.Type) { case ChatMessagePacket.ChannelMessage: if (string.IsNullOrEmpty(message.Receiver)) { // If this is a local chat message (no receiver is provided) if (sender.DefaultChannel == null) { rawMessage.Respond("No channel is set to be your local channel", ResponseStatus.Failed); return(true); } sender.DefaultChannel.BroadcastMessage(message); rawMessage.Respond(ResponseStatus.Success); return(true); } // Find the channel Channels.TryGetValue(message.Receiver.ToLower(), out var channel); if (channel == null || !sender.CurrentChannels.Contains(channel)) { // Not in this channel rawMessage.Respond($"You're not in the '{message.Receiver}' channel", ResponseStatus.Failed); return(true); } channel.BroadcastMessage(message); rawMessage.Respond(ResponseStatus.Success); return(true); case ChatMessagePacket.PrivateMessage: ChatUsers.TryGetValue(message.Receiver.ToLower(), out var receiver); if (receiver == null) { rawMessage.Respond($"User '{message.Receiver}' is not online", ResponseStatus.Failed); return(true); } receiver.Peer.SendMessage((short)OpCodes.ChatMessage, message); rawMessage.Respond(ResponseStatus.Success); return(true); } return(false); }
private void HandleChatMessage(Client client, ChatMessagePacket packet) { // TODO: Commands, spam filter, etc. packet.Username = client.Player.Username; Server.BroadcastPacket(packet); Logger.Chat(String.Format("<{0}> {1}", packet.Username, packet.Message)); }