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