private void UDPCommandListener()
{
UdpClient CommandListener = new UdpClient(ClientInfo.EndPoint());
Message responseData = Utilities.Serialize("ERR:Response Not Processed");
bool active = true;
try
{
while (active)
{
Console.WriteLine("UDP Waiting for broadcast");
IPEndPoint serverEP = ServerInfo.EndPoint();
Message message = new Message();
message.data = CommandListener.Receive(ref serverEP);
Console.WriteLine(ServerInfo);
object receivedData = Utilities.Deserialize(message);
if (receivedData is string)
{
switch ((string)receivedData)
{
case "CMD:Win":
this.OnRaiseClientWinEvent();
break;
case "CMD:Disconnect":
Console.WriteLine("Received Command: Disconnect");
active = false;
this.OnRaiseClientDisconnectedEvent(this.ClientInfo);
receivedData = "CMD:Disconnect";
responseData = Utilities.Serialize("RESPONSE:Disconnect");
break;
}
}
Console.WriteLine($"Received broadcast from {serverEP} :");
Console.WriteLine($" RSVP address {receivedData.ToString()}");
// Send the server verification that the response was received.
Console.WriteLine("UDP Client sending response");
CommandListener.Send(responseData.data, responseData.data.Length, serverEP);
}
}
catch (SocketException e)
{
Console.WriteLine(e);
}
catch (ThreadAbortException e)
{
Console.WriteLine("Thread Aborted: {0}", e);
Console.WriteLine("Disposing of UDP server");
}
finally
{
CommandListener.Close();
}
}
private void SendCommandToClient(HelloPacket targetClient, string command)
{
UdpClient client = new UdpClient();
Message request = new Message();
request = Utilities.Serialize(command);
IPEndPoint serverEP = new IPEndPoint(IPAddress.Any, 0);
client.Send(request.data, request.data.Length, targetClient.EndPoint());
Console.WriteLine($"Command {command} sent to the client: {targetClient.ToString()}");
Message responseMessage = new Message(256);
// s.Receive(responseMessage.data);
responseMessage.data = client.Receive(ref serverEP);
object responseData = Utilities.Deserialize(responseMessage);
Console.WriteLine($"Received respone from {responseData.ToString()}");
client.Close();
}
/// <summary>
/// This will be the way that clients are added to the current group.
/// Games can be hosted as open or closed. (closed will keep new players from joining)
/// Closed will be the default.
///
/// Returns a reference to the Listener
/// </summary>
private void ClientDiscover()
{
// UDP listener logic
Console.WriteLine($"Creating UDP server listener {HostInformation.ToString()}");
Message responseData = Utilities.Serialize(HostInformation);
try
{
// Stop listening when the game starts (in closed mode).
while (!ClosedGame)
{
Console.WriteLine("UDP Waiting for broadcast");
IPEndPoint clientEP = new IPEndPoint(IPAddress.Any, 0);
Message message = new Message();
message.data = server.Receive(ref clientEP);
if (!ClosedGame)
{
object receivedData = Utilities.Deserialize(message);
if (receivedData is HelloPacket)
{
// Add new client to Lists
HelloPacket newClient = receivedData as HelloPacket;
this.OnRaiseClientJoinedEvent(newClient);
}
if (receivedData is string)
{
switch (receivedData as string)
{
case "RESPONSE:Disconnect":
OnRaiseClientDisconnectedEvent(HostList.Find(HelloPacket => HelloPacket.EndPoint() == clientEP));
break;
}
}
Console.WriteLine($"Received broadcast from {clientEP} :");
Console.WriteLine($" RSVP address {receivedData.ToString()}");
// Add the client EndPoint to the ClientList
Console.WriteLine($"{clientEP} added to the clientlist");
ClientList.Add(clientEP);
// Send the server data to the client
Console.WriteLine("UDP Server sending response");
server.Send(responseData.data, responseData.data.Length, clientEP);
}
}
}
catch (SocketException e)
{
Console.WriteLine(e);
}
catch (ThreadAbortException e)
{
Console.WriteLine("Thread Aborted: {0}", e);
Console.WriteLine("Disposing of UDP server");
}
finally
{
server.Close();
}
}
