public static unsafe void DumpReliabilityStatistics(UdpNetworkDriver driver, NetworkPipeline pipeline, NetworkConnection con)
{
NativeSlice <byte> receiveBuffer = default;
NativeSlice <byte> sendBuffer = default;
NativeSlice <byte> sharedBuffer = default;
driver.GetPipelineBuffers(pipeline, 4, con, ref receiveBuffer, ref sendBuffer, ref sharedBuffer);
/*var relCtx = (ReliableUtility.SharedContext*)sharedBuffer.GetUnsafeReadOnlyPtr();
* var sendCtx = (ReliableUtility.Context*)sendBuffer.GetUnsafeReadOnlyPtr();
* UnityEngine.Debug.Log("Reliability stats\nPacketsDropped: " + relCtx->stats.PacketsDropped + "\n" +
* "PacketsDuplicated: " + relCtx->stats.PacketsDuplicated + "\n" +
* "PacketsOutOfOrder: " + relCtx->stats.PacketsOutOfOrder + "\n" +
* "PacketsReceived: " + relCtx->stats.PacketsReceived + "\n" +
* "PacketsResent: " + relCtx->stats.PacketsResent + "\n" +
* "PacketsSent: " + relCtx->stats.PacketsSent + "\n" +
* "PacketsStale: " + relCtx->stats.PacketsStale + "\n" +
* "Last received remote seqId: " + relCtx->ReceivedPackets.Sequence + "\n" +
* "Last received remote ackMask: " + SequenceHelpers.BitMaskToString(relCtx->ReceivedPackets.AckMask) + "\n" +
* "Last sent seqId: " + (relCtx->SentPackets.Sequence - 1)+ "\n" +
* "Last acked seqId: " + relCtx->SentPackets.Acked + "\n" +
* "Last ackmask: " + SequenceHelpers.BitMaskToString(relCtx->SentPackets.AckMask));*/
}
void Start()
{
driver = new UdpNetworkDriver(new INetworkParameter[0]);
var endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 54321;
if (driver.Bind(endpoint) != 0)
{
serverStatus.text = "Server Status: Port Failure";
}
else
{
driver.Listen();
serverStatus.text = "Server Status: Online";
}
connections = new NativeList <NetworkConnection>(16, Allocator.Persistent);
clientTimers = new NativeList <float>(16, Allocator.Persistent);
clientMessages = new List <string>();
clientPositions = new List <Vector2>();
clientMessagesLabel.text = "";
dropTime = 2.0f;
moveSpeed = 10f;
}
public void UdpC_ConnectTest_ShouldConnect()
{
using (var server = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
using (var client = new UdpNetworkDriver(new NetworkDataStreamParameter {
}))
{
var serverPort = 50009;
server.Bind(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
client.Bind(NetworkEndPoint.LoopbackIpv4);
server.Listen();
var id = client.Connect(NetworkEndPoint.CreateIpv4(0x7f000001, (ushort)serverPort));
NetworkConnection serverConnection, clientConnection;
int maxIterations = 100;
ConnectTogether(server, client, maxIterations, out serverConnection, out clientConnection);
Assert.AreEqual(id, serverConnection);
}
}
void Start()
{
// Create a NetworkDriver for the client. We could bind to a specific address but in this case we rely on the
// implicit bind since we do not need to bing to anything special
m_ClientDriver = new UdpNetworkDriver(new INetworkParameter[0]);
ServerEndPoint = default(NetworkEndPoint);
if (string.IsNullOrEmpty(m_CustomIp))
{
var endpoint = NetworkEndPoint.LoopbackIpv4;
endpoint.Port = port;
ServerEndPoint = endpoint;
}
else
{
string[] endpoint = m_CustomIp.Split(':');
ushort newPort = 0;
if (endpoint.Length > 1 && ushort.TryParse(endpoint[1], out newPort))
{
port = newPort;
}
Debug.Log($"Connecting to PingServer at {endpoint[0]}:{port}.");
ServerEndPoint = NetworkEndPoint.Parse(endpoint[0], port);
}
}
// Create the ping server driver, bind it to a port and start listening for incoming connections
void InitializePingServer()
{
m_ServerDriver = new UdpNetworkDriver(new INetworkParameter[0]);
var bindError = m_ServerDriver.Bind(m_PingServerEndpoint);
if (bindError != 0)
{
Debug.LogError($"Failed to bind to {m_Config.ServerIpAddress ?? "0.0.0.0"}:{m_Config.Info.Port}. Bind error code: {bindError}.");
ShutdownServer(1);
}
else
{
Debug.Log($"Network driver listening for traffic on {m_Config.ServerIpAddress ?? "0.0.0.0"}:{m_Config.Info.Port}");
m_ServerDriver.Listen();
}
m_Connections = new NativeList <NetworkConnection>(m_Config.Info.MaxPlayers, Allocator.Persistent);
m_ShouldShutdownServer = new NativeArray <bool>(1, Allocator.Persistent)
{
[0] = false
};
}
// Use this for initialization
void Start()
{
ushort serverPort = 9000;
int playerCount = 16;
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = serverPort;
Driver = new UdpNetworkDriver(new INetworkParameter[0]);
if (Driver.Bind(endpoint) != 0)
{
Debug.Log($"Failed to bind to port {serverPort}");
}
else
{
Driver.Listen();
}
Connections = new NativeList <NetworkConnection>(playerCount, Allocator.Persistent);
Players = new NativeList <ClientPlayer>(playerCount, Allocator.Persistent);
PlayerObjects = new Dictionary <int, GameObject>();
}
private void HandleIndividualPlayerSend(ref NativeList <NetworkConnection> connections, ref UdpNetworkDriver driver)
{
// Send messages meant for individual players
for (int index = 0; index < connections.Length; ++index)
{
Queue <byte> playerQueue = individualSendQueues[index];
if (playerQueue.Count > 0)
{
// Send eveyrthing in the queue
using (var writer = new DataStreamWriter(playerQueue.Count, Allocator.Temp))
{
while (playerQueue.Count > 0)
{
byte data = playerQueue.Dequeue();
if (!connections[index].IsCreated)
{
Debug.Log("FakeServerLobbySend::HandleIndividualPlayerSend connections[" + index + "] was not created");
Assert.IsTrue(true);
}
writer.Write(data);
}
connections[index].Send(driver, writer);
}
}
}
}
void AllocateServerAttributes()
{
m_ClientDriver = new UdpNetworkDriver(new INetworkParameter[0]);
m_clientToServerConnection = new NativeArray <NetworkConnection>(1, Allocator.Persistent);
}
void Start()
{
// Create a NetworkDriver for the client. We could bind to a specific address but in this case we rely on the
// implicit bind since we do not need to bing to anything special
m_ClientDriver = new UdpNetworkDriver(new INetworkParameter[0]);
}
protected override JobHandle OnUpdate(JobHandle inputDep)
{
var commandBuffer = m_Barrier.CreateCommandBuffer();
// Destroy drivers if the PingDriverComponents were removed
if (!m_DestroyedDriverGroup.IsEmptyIgnoreFilter)
{
inputDep.Complete();
var destroyedDriverEntity = m_DestroyedDriverGroup.ToEntityArray(Allocator.TempJob);
var destroyedDriverList = m_DestroyedDriverGroup.ToComponentDataArray <PingDriverComponentData>(Allocator.TempJob);
for (int i = 0; i < destroyedDriverList.Length; ++i)
{
if (destroyedDriverList[i].isServer != 0)
{
var serverConnectionList = m_ServerConnectionGroup.ToEntityArray(Allocator.TempJob);
// Also destroy all active connections when the driver dies
for (int con = 0; con < serverConnectionList.Length; ++con)
{
commandBuffer.DestroyEntity(serverConnectionList[con]);
}
serverConnectionList.Dispose();
ServerDriver.Dispose();
}
else
{
ClientDriver.Dispose();
}
commandBuffer.RemoveComponent <PingDriverStateComponent>(destroyedDriverEntity[i]);
}
destroyedDriverList.Dispose();
destroyedDriverEntity.Dispose();
}
// Create drivers if new PingDriverComponents were added
if (!m_NewDriverGroup.IsEmptyIgnoreFilter)
{
inputDep.Complete();
var newDriverEntity = m_NewDriverGroup.ToEntityArray(Allocator.TempJob);
var newDriverList = m_NewDriverGroup.ToComponentDataArray <PingDriverComponentData>(Allocator.TempJob);
for (int i = 0; i < newDriverList.Length; ++i)
{
if (newDriverList[i].isServer != 0)
{
if (ServerDriver.IsCreated)
{
throw new InvalidOperationException("Cannot create multiple server drivers");
}
var drv = new UdpNetworkDriver(new INetworkParameter[0]);
var addr = NetworkEndPoint.AnyIpv4;
addr.Port = 9000;
if (drv.Bind(addr) != 0)
{
throw new Exception("Failed to bind to port 9000");
}
else
{
drv.Listen();
}
ServerDriver = drv;
ConcurrentServerDriver = ServerDriver.ToConcurrent();
}
else
{
if (ClientDriver.IsCreated)
{
throw new InvalidOperationException("Cannot create multiple client drivers");
}
ClientDriver = new UdpNetworkDriver(new INetworkParameter[0]);
ConcurrentClientDriver = ClientDriver.ToConcurrent();
}
commandBuffer.AddComponent(newDriverEntity[i],
new PingDriverStateComponent {
isServer = newDriverList[i].isServer
});
}
newDriverList.Dispose();
newDriverEntity.Dispose();
}
JobHandle clientDep = default(JobHandle);
JobHandle serverDep = default(JobHandle);
// Go through and update all drivers, also accept all incoming connections for server drivers
if (ServerDriver.IsCreated)
{
// Schedule a chain with driver update, a job to accept all connections and finally a job to delete all invalid connections
serverDep = ServerDriver.ScheduleUpdate(inputDep);
var acceptJob = new DriverAcceptJob
{
driver = ServerDriver, commandBuffer = commandBuffer
};
serverDep = acceptJob.Schedule(serverDep);
var cleanupJob = new DriverCleanupJob
{
commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent()
};
serverDep = cleanupJob.Schedule(this, serverDep);
m_Barrier.AddJobHandleForProducer(serverDep);
}
if (ClientDriver.IsCreated)
{
clientDep = ClientDriver.ScheduleUpdate(inputDep);
}
return(JobHandle.CombineDependencies(clientDep, serverDep));
}
public IEnumerator ServerAnd5Clients_Connect_Successfully()
{
int numberOfClients = 5;
NativeArray <NetworkConnection> connectionToClientArray;
UdpNetworkDriver[] client_driversArray = new UdpNetworkDriver[numberOfClients];
NativeArray <NetworkConnection> clientToServerConnectionsArray;
//setup server
connectionToClientArray = new NativeArray <NetworkConnection>(numberOfClients, Allocator.Persistent);
server_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 0
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
server_driver.Bind(server_endpoint);
server_driver.Listen();
//setup clients
clientToServerConnectionsArray = new NativeArray <NetworkConnection>(numberOfClients, Allocator.Persistent);
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i] = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 0
});
clientToServerConnectionsArray[i] = client_driversArray[i].Connect(server_endpoint);
}
//update drivers
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i].ScheduleUpdate().Complete();
}
server_driver.ScheduleUpdate().Complete();
//accept connections
for (int i = 0; i < numberOfClients; i++)
{
connectionToClientArray[i] = server_driver.Accept();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClientArray[i], out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, "Not empty NetworkEvent on the server appeared");
client_driversArray[i].ScheduleUpdate().Complete();
ev = clientToServerConnectionsArray[i].PopEvent(client_driversArray[i], out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, "NetworkEvent should have Type.Connect on the client");
}
//close connections
for (int i = 0; i < numberOfClients; i++)
{
clientToServerConnectionsArray[i].Close(client_driversArray[i]);
//update drivers
client_driversArray[i].ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClientArray[i], out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + "appeared");
}
server_driver.Dispose();
for (int i = 0; i < numberOfClients; i++)
{
client_driversArray[i].Dispose();
}
connectionToClientArray.Dispose();
clientToServerConnectionsArray.Dispose();
yield return(null);
}
public void SendAndReceiveMessage_RealNetwork()
{
using (var clientSendData = new DataStreamWriter(64, Allocator.Persistent))
{
DataStreamReader stream;
var serverEndpoint = NetworkEndPoint.LoopbackIpv4;
serverEndpoint.Port = (ushort)Random.Range(2000, 65000);
var serverDriver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(serverEndpoint);
serverDriver.Listen();
var clientDriver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
clientDriver.Bind(NetworkEndPoint.LoopbackIpv4);
var clientToServerId = clientDriver.Connect(serverEndpoint);
NetworkConnection serverToClientId = default(NetworkConnection);
// Retry a few times since the network might need some time to process
for (int i = 0; i < 10 && serverToClientId == default(NetworkConnection); ++i)
{
serverDriver.ScheduleUpdate().Complete();
serverToClientId = serverDriver.Accept();
}
Assert.That(serverToClientId != default(NetworkConnection));
clientDriver.ScheduleUpdate().Complete();
var eventId = clientDriver.PopEventForConnection(clientToServerId, out stream);
Assert.That(eventId == NetworkEvent.Type.Connect);
int testInt = 100;
float testFloat = 555.5f;
byte[] testByteArray = Encoding.ASCII.GetBytes("Some bytes blablabla 1111111111111111111");
clientSendData.Write(testInt);
clientSendData.Write(testFloat);
clientSendData.Write(testByteArray.Length);
clientSendData.Write(testByteArray);
var sentBytes = clientDriver.Send(NetworkPipeline.Null, clientToServerId, clientSendData);
// Header size is included in the sent bytes count (4 bytes overhead)
Assert.AreEqual(clientSendData.Length + 4, sentBytes);
clientDriver.ScheduleUpdate().Complete();
serverDriver.ScheduleUpdate().Complete();
DataStreamReader serverReceiveStream;
eventId = serverDriver.PopEventForConnection(serverToClientId, out serverReceiveStream);
var readerCtx = default(DataStreamReader.Context);
Assert.True(eventId == NetworkEvent.Type.Data);
var receivedInt = serverReceiveStream.ReadInt(ref readerCtx);
var receivedFloat = serverReceiveStream.ReadFloat(ref readerCtx);
var byteArrayLength = serverReceiveStream.ReadInt(ref readerCtx);
var receivedBytes = serverReceiveStream.ReadBytesAsArray(ref readerCtx, byteArrayLength);
Assert.True(testInt == receivedInt);
Assert.That(Mathf.Approximately(testFloat, receivedFloat));
Assert.AreEqual(testByteArray, receivedBytes);
clientDriver.Dispose();
serverDriver.Dispose();
}
}
protected override void PutPlayCommand(UdpNetworkDriver driver, NetworkConnection connection, DataStreamReader strm)
{
PutPlayResponseData responseReceived = new PutPlayResponseData(strm);
TimeLogger.Log("CLIENT {0} - response - PutPlay success", ((ClientCommunication)owner).ClientId);
}
public static unsafe void GatherReliabilityStats(ref SoakStatisticsPoint stats, ref SoakStatisticsPoint lastStats, UdpNetworkDriver driver,
NetworkPipeline pipeline, NetworkConnection con, long timestamp)
{
NativeSlice <byte> receiveBuffer = default;
NativeSlice <byte> sendBuffer = default;
NativeSlice <byte> sharedBuffer = default;
driver.GetPipelineBuffers(pipeline, 4, con, ref receiveBuffer, ref sendBuffer, ref sharedBuffer);
var sharedCtx = (ReliableUtility.SharedContext *)sharedBuffer.GetUnsafeReadOnlyPtr();
stats.ReliableSent += sharedCtx->stats.PacketsSent - lastStats.ReliableSent;
//Console.WriteLine("sharedCtx->stats.PacketsSent=" + sharedCtx->stats.PacketsSent + " lastStats.ReliableSent=" + lastStats.ReliableSent + " stats.ReliableSent=" + stats.ReliableSent);
stats.ReliableResent += sharedCtx->stats.PacketsResent - lastStats.ReliableResent;
stats.ReliableDropped += sharedCtx->stats.PacketsDropped - lastStats.ReliableDropped;
stats.ReliableReceived += sharedCtx->stats.PacketsReceived - lastStats.ReliableReceived;
stats.ReliableDuplicate += sharedCtx->stats.PacketsDuplicated - lastStats.ReliableDuplicate;
stats.ReliableRTT = sharedCtx->RttInfo.LastRtt;
stats.ReliableSRTT = sharedCtx->RttInfo.SmoothedRtt;
int resendQueueSize = 0;
int oldestResendPacketAge = 0;
int maxRtt = 0;
int maxProcessingTime = 0;
GatherExtraStats(sendBuffer, sharedBuffer, timestamp, ref resendQueueSize, ref oldestResendPacketAge, ref maxRtt, ref maxProcessingTime);
stats.ReliableResendQueue = resendQueueSize;
stats.ReliableOldestResendPacketAge = oldestResendPacketAge;
stats.ReliableMaxRTT = maxRtt;
stats.ReliableMaxProcessingTime = maxProcessingTime;
lastStats.ReliableSent = sharedCtx->stats.PacketsSent;
lastStats.ReliableResent = sharedCtx->stats.PacketsResent;
lastStats.ReliableDropped = sharedCtx->stats.PacketsDropped;
lastStats.ReliableReceived = sharedCtx->stats.PacketsReceived;
lastStats.ReliableDuplicate = sharedCtx->stats.PacketsDuplicated;
}
public ProcessServerCommandCoroutine(ServerCommunication owner, UdpNetworkDriver driver, CommunicationJobHandler jobHandler) :
base(owner, driver, jobHandler)
{
}
public void ScheduleDriverUpdate(UdpNetworkDriver driver)
{
m_updateHandle = driver.ScheduleUpdate();
}
protected abstract void Write(ref UdpNetworkDriver m_Driver, NetworkConnection networkConnection);
void Start()
{
m_Driver = new UdpNetworkDriver(new INetworkParameter[0]);
Connect();
}
protected virtual void GetResultsCommand(UdpNetworkDriver driver, NetworkConnection connection, DataStreamReader strm)
{
throw new System.Exception("ProcessCommandCoroutine child must implements own GetResultsCommand");
}
