public void SetupServerAndClientAndConnectThem(int bufferSize)
{
//setup server
server_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = bufferSize
});
NetworkEndPoint server_endpoint = NetworkEndPoint.LoopbackIpv4;
server_endpoint.Port = 1337;
server_driver.Bind(server_endpoint);
server_driver.Listen();
//setup client
client_driver = new UdpNetworkDriver(new NetworkDataStreamParameter {
size = bufferSize
});
clientToServerConnection = client_driver.Connect(server_endpoint);
//update drivers
client_driver.ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
//accept connection
connectionToClient = server_driver.Accept();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Empty, "Not empty NetworkEvent on the server appeared");
client_driver.ScheduleUpdate().Complete();
ev = clientToServerConnection.PopEvent(client_driver, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Connect, "NetworkEvent should have Type.Connect on the client");
}
void Update()
{
m_Driver.ScheduleUpdate().Complete();
RemoveOldConnections();
AddNewConnections();
QueryForNewEvents();
}
void Update()
{
if (m_Connected)
{
SendLoop();
}
m_Driver.ScheduleUpdate().Complete();
DataStreamReader stream;
NetworkEvent.Type cmd;
while ((cmd = m_Connection.PopEvent(m_Driver, out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("We are now connected to the server");
m_Connected = true;
}
else if (cmd == NetworkEvent.Type.Data)
{
Read(stream);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client got disconnected from server");
}
}
}
void Update()
{
m_Driver.ScheduleUpdate().Complete();
CleanConnect();
NewConnect();
CheckConnect();
}
private void Update()
{
if (!started)
{
return;
}
driver.ScheduleUpdate().Complete();
if (!connection.IsCreated)
{
return;
}
DataStreamReader sr;
NetworkEvent.Type cmd;
while ((cmd = connection.PopEvent(driver, out sr)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
}
if (cmd == NetworkEvent.Type.Disconnect)
{
}
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
byte[] data = sr.ReadBytesAsArray(ref readerCtx, sr.Length);
string cmdString = System.Text.Encoding.UTF8.GetString(data);
ProcessCommand(cmdString);
}
}
}
void Update()
{
driver.ScheduleUpdate().Complete();
AcceptNewConnections();
numClients.text = "Clients: " + connections.Length.ToString();
PrintClientMessages();
UpdateClientPositions(Time.deltaTime);
DataStreamReader stream;
for (int i = 0; i < connections.Length; i++)
{
if (!connections[i].IsCreated)
{
Assert.IsTrue(true);
}
clientTimers[i] += Time.deltaTime;
if (clientTimers[i] > dropTime)
{
DropConnection(i);
}
else
{
NetworkEvent.Type cmd;
while ((cmd = driver.PopEventForConnection(connections[i], out stream)) != NetworkEvent.Type.Empty)
{
clientMessages[i] = ReadMessage(stream);
clientTimers[i] = 0;
SendMessage(GenerateFinalString(), driver, connections[i]);
}
}
}
}
void ConnectTogether(UdpNetworkDriver server, UdpNetworkDriver client, int maxIterations, out NetworkConnection serverConnection, out NetworkConnection clientConnection)
{
int servers = 0, clients = 0, iterations = 0;
serverConnection = default(NetworkConnection);
clientConnection = default(NetworkConnection);
DataStreamReader reader;
NetworkConnection poppedConnection = default(NetworkConnection);
while (clients != 1 || servers != 1)
{
Assert.Less(iterations++, maxIterations);
server.ScheduleUpdate().Complete();
var newConnection = server.Accept();
if (newConnection != default(NetworkConnection))
{
clients++;
clientConnection = newConnection;
}
if (client.PopEvent(out poppedConnection, out reader) == ExperimentalEventType.Connect)
{
serverConnection = poppedConnection;
servers++;
}
client.ScheduleUpdate().Complete();
Assert.AreNotEqual(clientConnection, default(NetworkConnection));
}
}
void SendReceive(UdpNetworkDriver sender, UdpNetworkDriver receiver, NetworkConnection from, NetworkConnection to, byte[] data, int maxIterations)
{
using (var writer = new DataStreamWriter(data.Length, Allocator.Persistent))
{
writer.Write(data, data.Length);
// sender.Send(to, writer); // old one preserved to explain how names were chosen :-)
to.Send(sender, writer); // new :-)
sender.ScheduleUpdate().Complete();
receiver.ScheduleUpdate().Complete();
var buffer = new byte[1472];
int size = 0;
NetworkConnection connection;
PollEvent(ExperimentalEventType.Data, maxIterations, receiver, ref buffer, out size, out connection);
Assert.AreEqual(from, connection);
Assert.AreEqual(data.Length, size);
for (int i = 0; i < data.Length; i++)
{
Assert.AreEqual(data[i], buffer[i]);
}
}
}
ExperimentalEventType PollEvent(ExperimentalEventType ev, int maxIterations, UdpNetworkDriver socket, ref byte[] buffer, out int size, out NetworkConnection connection)
{
int iterator = 0;
size = 0;
connection = default(NetworkConnection);
while (iterator++ < maxIterations)
{
DataStreamReader reader;
var context = default(DataStreamReader.Context);
ExperimentalEventType e;
if ((e = socket.PopEvent(out connection, out reader)) == ev)
{
if (reader.IsCreated)
{
reader.ReadBytesIntoArray(ref context, ref buffer, reader.Length);
size = reader.Length;
}
return(e);
}
socket.ScheduleUpdate().Complete();
}
return(ExperimentalEventType.Empty);
}
public void Update()
{
m_Tick++;
m_UpdateHandle.Complete();
if (m_PendingDisconnects.IsCreated)
{
m_PendingDisconnects.Dispose();
}
var acceptJob = new SoakServerAcceptJob
{
now = m_Tick,
driver = m_ServerDriver,
connections = m_Connections
};
var soakJob = new SoakServerUpdateClientsJob
{
driver = m_ServerDriver.ToConcurrent(),
pipeline = m_Pipeline,
connections = m_Connections.AsDeferredJobArray()
};
/*var time = Time.fixedTime;
* if (time > m_NextStatsPrint)
* {
* PrintStatistics();
* m_NextStatsPrint = time + 10;
* }*/
m_UpdateHandle = m_ServerDriver.ScheduleUpdate();
m_UpdateHandle = acceptJob.Schedule(m_UpdateHandle);
m_UpdateHandle = soakJob.Schedule(m_Connections, 1, m_UpdateHandle);
}
// Update is called once per frame
void Update()
{
m_Driver.ScheduleUpdate().Complete();
// Clean up connections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
// Accept new connections
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
m_Connections.Add(c);
Debug.Log("Accepted a connection");
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
//read received packet
DataStreamReader.Context readerCtx = default(DataStreamReader.Context);
PacketFunctions.ReadPacket(stream, ref readerCtx);
StartCoroutine(SendHelloClient(m_Connections[i]));
/*
* var readerCtx = default(DataStreamReader.Context);
* uint number = stream.ReadUInt(ref readerCtx);
* using (var writer = new DataStreamWriter(4, Allocator.Temp))
* {
* writer.Write(number);
* //other option
* //m_Connections[i].Send(m_Driver, writer);
* m_Driver.Send(NetworkPipeline.Null, m_Connections[i], writer);
* }
*/
}
}
}
}
// Update is called once per frame
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
// Clean up connections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
// Accept new connections
NetworkConnection connection;
while ((connection = m_Driver.Accept()) != default(NetworkConnection))
{
m_Connections.Add(connection);
Debug.Log("Accepted a connection");
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
continue;
}
NetworkEvent.Type cmd;
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
uint number = stream.ReadUInt(ref readerCtx);
Debug.Log("Got " + number + " from the client adding + 2 to it and sending it back.");
number += 2;
using (var writer = new DataStreamWriter(4, Allocator.Temp))
{
writer.Write(number);
m_Driver.Send(m_Pipeline, m_Connections[i], writer);
}
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from the server.");
m_Connections[i] = default;
}
}
}
}
void Update()
{
m_Driver.ScheduleUpdate().Complete();
if (!m_Connection.IsCreated)
{
if (!Done)
{
Debug.Log("Something went wrong during connect");
}
return;
}
DataStreamReader stream;
NetworkEvent.Type cmd;
while ((cmd = m_Connection.PopEvent(m_Driver, out stream)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("We are now connected to the server");
using (var writer = PacketFunctions.WritePacket(GameEvent.HELLO_SERVER)) {
//m_Connection.Send(m_Driver, writer);
m_Connection.Send(m_Driver, reliableUdpPipe, writer);
}
/*
* var value = 1;
* using (var writer = new DataStreamWriter(4, Allocator.Temp))
* {
* writer.Write(value);
* m_Connection.Send(m_Driver, writer);
* }
*/
}
else if (cmd == NetworkEvent.Type.Data)
{
//read received packet
DataStreamReader.Context readerCtx = default(DataStreamReader.Context);
PacketFunctions.ReadPacket(stream, ref readerCtx, PushToScreen);
/*
* // var readerCtx = default(DataStreamReader.Context);
* uint value = stream.ReadUInt(ref readerCtx);
* Debug.Log("Got the value = " + value + " back from the server");
* Done = true;
* m_Connection.Disconnect(m_Driver);
* m_Connection = default(NetworkConnection);
*/
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client got disconnected from server");
m_Connection = default(NetworkConnection);
}
}
}
void WaitForNetworkUpdate()
{
// The DriverUpdateJob which accepts new connections should be the second job in the chain,
// it needs to depend on the driver update job
var updateJob = new DriverUpdateJob
{
driver = m_ServerDriver,
connections = m_Connections
};
// Update the driver should be the first job in the chain
m_UpdateHandle = m_ServerDriver.ScheduleUpdate(m_UpdateHandle);
m_UpdateHandle = updateJob.Schedule(m_UpdateHandle);
// Wait for the job to complete
m_UpdateHandle.Complete();
}
/// <summary>
/// Updates network events.
/// </summary>
private void updateNetworkEvents()
{
if (networkEndPoint != null)
{
//Complete C# JobHandle to ensure network event updates can be processed
networkDriver.ScheduleUpdate().Complete();
}
}
void Update()
{
//Debug.Log("Server is active!");
m_Driver.ScheduleUpdate().Complete();
CleanUpConnections();
AcceptNewConnections();
RoundRobinConnections();
}
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
// CleanUpConnections
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
Debug.Log($"Connection {i} has been cleaned up");
m_Connections.RemoveAtSwapBack(i);
--i;
}
}
NetworkConnection c;
while ((c = m_Driver.Accept()) != default(NetworkConnection))
{
Debug.Log($"New user connected: {c.InternalId}");
m_Connections.Add(c);
ClientConnected(c);
OnClientConnected?.Invoke(c);
}
DataStreamReader stream;
for (int i = 0; i < m_Connections.Length; i++)
{
if (!m_Connections[i].IsCreated)
{
Assert.IsTrue(true);
}
NetworkEvent.Type cmd;
var readerCtx = default(DataStreamReader.Context);
while ((cmd = m_Driver.PopEventForConnection(m_Connections[i], out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
Read(i, stream, ref readerCtx);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client disconnected from server");
m_Connections[i] = default(NetworkConnection);
ClientDisconnected(m_Connections[i].InternalId);
OnClientDisconnected?.Invoke(m_Connections[i].InternalId);
}
}
}
OnUpdate();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
inputDeps.Complete();
JobHandle serverJobHandle;
//Debug.Log("server system on update");
if (!m_Driver.IsCreated)
{
ReliableUtility.Parameters reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
SimulatorUtility.Parameters simulatorParams = new SimulatorUtility.Parameters {
MaxPacketSize = k_PacketSize, MaxPacketCount = 30, PacketDelayMs = 100
};
m_Driver = new UdpNetworkDriver(simulatorParams, reliabilityParams);
NetworkEndPoint endpoint = NetworkEndPoint.AnyIpv4;
endpoint.Port = 9000;
if (m_Driver.Bind(endpoint) != 0)
{
Debug.Log("Failed to bind to port 9000");
}
else
{
m_Driver.Listen();
Debug.Log("driver listening on port 9000");
}
currentId = new NativeList <int>(1, Allocator.Persistent);
currentId.Add(0);
}
else
{
serverJobHandle = m_Driver.ScheduleUpdate(inputDeps);
serverJobHandle = new ListenForConnectionsJob
{
commandBuffer = m_Barrier.CreateCommandBuffer(),
driver = m_Driver,
}.Schedule(serverJobHandle);
serverJobHandle.Complete();
serverJobHandle = new UpdateServerJob
{
commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(),
driver = m_Driver.ToConcurrent(),
id = currentId.AsDeferredJobArray()
}.Schedule(this, serverJobHandle);
m_Barrier.AddJobHandleForProducer(serverJobHandle);
//Debug.Log("about to listen for connections");
return(serverJobHandle);
}
return(inputDeps);
}
void ValidateConnection()
{
m_Driver.ScheduleUpdate().Complete();
if (!m_Connection.IsCreated)
{
clientStatus.text = "Client Status: Error";
return;
}
}
void FixedUpdate()
{
if (!m_ServerDriver.IsCreated)
{
return;
}
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ServerDriver.ScheduleUpdate().Complete();
// Accept all new connections
while (true)
{
var con = m_ServerDriver.Accept();
// "Nothing more to accept" is signaled by returning an invalid connection from accept
if (!con.IsCreated)
{
break;
}
m_connections.Add(con);
}
for (int i = 0; i < m_connections.Length; ++i)
{
DataStreamReader strm;
NetworkEvent.Type cmd;
// Pop all events for the connection
while ((cmd = m_ServerDriver.PopEventForConnection(m_connections[i], out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Data)
{
// For ping requests we reply with a pong message
// A DataStreamReader.Context is required to keep track of current read position since
// DataStreamReader is immutable
var readerCtx = default(DataStreamReader.Context);
int id = strm.ReadInt(ref readerCtx);
// Create a temporary DataStreamWriter to keep our serialized pong message
var pongData = new DataStreamWriter(4, Allocator.Temp);
pongData.Write(id);
// Send the pong message with the same id as the ping
m_ServerDriver.Send(NetworkPipeline.Null, m_connections[i], pongData);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// This connection no longer exist, remove it from the list
// The next iteration will operate on the new connection we swapped in so as long as it exist the
// loop can continue
m_connections.RemoveAtSwapBack(i);
if (i >= m_connections.Length)
{
break;
}
}
}
}
}
void FixedUpdate()
{
// Update the ping client UI with the ping statistics computed by teh job scheduled previous frame since that
// is now guaranteed to have completed
PingClientUIBehaviour.UpdateStats(m_numPingsSent, m_lastPingTime);
// Update the NetworkDriver. It schedules a job so we must wait for that job with Complete
m_ClientDriver.ScheduleUpdate().Complete();
// If the client ui indicates we should be sending pings but we do not have an active connection we create one
if (PingClientUIBehaviour.ServerEndPoint.IsValid && !m_clientToServerConnection.IsCreated)
{
m_clientToServerConnection = m_ClientDriver.Connect(PingClientUIBehaviour.ServerEndPoint);
}
// If the client ui indicates we should not be sending pings but we do have a connection we close that connection
if (!PingClientUIBehaviour.ServerEndPoint.IsValid && m_clientToServerConnection.IsCreated)
{
m_clientToServerConnection.Disconnect(m_ClientDriver);
m_clientToServerConnection = default(NetworkConnection);
}
DataStreamReader strm;
NetworkEvent.Type cmd;
// Process all events on the connection. If the connection is invalid it will return Empty immediately
while ((cmd = m_clientToServerConnection.PopEvent(m_ClientDriver, out strm)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
// When we get the connect message we can start sending data to the server
// Set the ping id to a sequence number for the new ping we are about to send
m_pendingPing = new PendingPing {
id = m_numPingsSent, time = Time.fixedTime
};
// Create a 4 byte data stream which we can store our ping sequence number in
var pingData = new DataStreamWriter(4, Allocator.Temp);
pingData.Write(m_numPingsSent);
m_clientToServerConnection.Send(m_ClientDriver, pingData);
// Update the number of sent pings
++m_numPingsSent;
}
else if (cmd == NetworkEvent.Type.Data)
{
// When the pong message is received we calculate the ping time and disconnect
m_lastPingTime = (int)((Time.fixedTime - m_pendingPing.time) * 1000);
m_clientToServerConnection.Disconnect(m_ClientDriver);
m_clientToServerConnection = default(NetworkConnection);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
// If the server disconnected us we clear out connection
m_clientToServerConnection = default(NetworkConnection);
}
}
}
// Update is called once per frame
void Update()
{
Driver.ScheduleUpdate().Complete();
if (!Connection.IsCreated)
{
if (!Done)
{
Debug.Log("Somthing went wront during connect");
return;
}
}
DataStreamReader stream;
NetworkEvent.Type netEvent;
// pops events for our single server connections
while ((netEvent = Connection.PopEvent(Driver, out stream)) != NetworkEvent.Type.Empty)
{
// NetworkEvent Connected
// Received a ConnectionAccepted message
if (netEvent == NetworkEvent.Type.Connect)
{
Debug.Log("We are now connected to the server");
uint value = 1;
using (DataStreamWriter connectionWriter = new DataStreamWriter(4, Allocator.Temp))
{
connectionWriter.Write(value);
Connection.Send(Driver, connectionWriter);
}
}
// NetworkEvent Data
else if (netEvent == NetworkEvent.Type.Data)
{
DataStreamReader.Context readerContext = default(DataStreamReader.Context);
uint value = stream.ReadUInt(ref readerContext);
Debug.Log($"Got the value = {value} back from the server");
Done = true;
Connection.Disconnect(Driver);
Connection = default(NetworkConnection);
}
// Network Disconnect
else if (netEvent == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client got disconnected from server");
Connection = default(NetworkConnection);
}
}
}
// Update is called once per frame
private void Update()
{
m_Driver.ScheduleUpdate().Complete();
if (!m_Connection.IsCreated)
{
if (!Done)
{
Debug.Log("Something went wrong during connection");
}
return;
}
NetworkEvent.Type cmd;
while ((cmd = m_Connection.PopEvent(m_Driver, out DataStreamReader stream)) != NetworkEvent.Type.Empty)
{
switch (cmd)
{
case NetworkEvent.Type.Connect:
Debug.Log("We are now connected to the server.");
var value = 1;
using (var writer = new DataStreamWriter(4, Allocator.Temp))
{
writer.Write(value);
m_Connection.Send(m_Driver, writer);
}
break;
case NetworkEvent.Type.Data:
var readerCtx = default(DataStreamReader.Context);
uint streamValue = stream.ReadUInt(ref readerCtx);
Debug.Log("Got the value = " + streamValue + " back from the server.");
Done = true;
m_Connection.Disconnect(m_Driver);
m_Connection = default;
break;
case NetworkEvent.Type.Disconnect:
Debug.Log("Client got disconnected from the server.");
m_Connection = default;
break;
case NetworkEvent.Type.Empty:
break;
}
}
}
// Update is called once per frame
void Update()
{
Driver.ScheduleUpdate().Complete();
CleanConnections();
AcceptConnections();
UpdateClients();
HandleConnections();
}
public void DisconnectAndCleanup()
{
clientToServerConnection.Close(client_driver);
//update drivers
client_driver.ScheduleUpdate().Complete();
server_driver.ScheduleUpdate().Complete();
ev = server_driver.PopEventForConnection(connectionToClient, out stream);
Assert.IsTrue(ev == NetworkEvent.Type.Disconnect, "NetworkEvent.Type.Disconnect was expected to appear, but " + ev + "appeared");
server_driver.Dispose();
client_driver.Dispose();
}
protected override JobHandle OnUpdate(JobHandle inputDeps)
{
inputDeps.Complete();
JobHandle clientJobHandle;
if (!m_Driver.IsCreated)
{
ReliableUtility.Parameters reliabilityParams = new ReliableUtility.Parameters {
WindowSize = 32
};
SimulatorUtility.Parameters simulatorParams = new SimulatorUtility.Parameters {
MaxPacketSize = k_PacketSize, MaxPacketCount = 30, PacketDelayMs = 100
};
m_Driver = new UdpNetworkDriver(simulatorParams, reliabilityParams);
m_Server_EndPoint = NetworkEndPoint.LoopbackIpv4;
m_Server_EndPoint.Port = 9000;
}
else
{
clientJobHandle = m_Driver.ScheduleUpdate(inputDeps);
if (m_Server_EndPoint.IsValid && m_ConnectionGroup.IsEmptyIgnoreFilter)
{
//Debug.Log("client job handle about to be created");
clientJobHandle = new SendConnectionRequestJob
{
commandBuffer = m_Barrier.CreateCommandBuffer(),
driver = m_Driver,
serverEndPoint = m_Server_EndPoint,
}.Schedule(clientJobHandle);
}
clientJobHandle.Complete();
clientJobHandle = new UpdateClientJob
{
commandBuffer = m_Barrier.CreateCommandBuffer().ToConcurrent(),
driver = m_Driver.ToConcurrent(),
serverEndPoint = m_Server_EndPoint,
}.Schedule(this, clientJobHandle);
m_Barrier.AddJobHandleForProducer(clientJobHandle);
return(clientJobHandle);
}
return(inputDeps);
}
void Update()
{
m_Driver.ScheduleUpdate().Complete();
if (!m_Connection.IsCreated)
{
if (!m_Done)
{
Debug.Log("Something went wrong during connect");
}
return;
}
DataStreamReader stream;
NetworkEvent.Type cmd;
while ((cmd = m_Connection.PopEvent(m_Driver, out stream)) !=
NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("We are now connected to the server");
CustomType customType = new CustomType()
{
val = 1
};
var buff = cts.Serialize(customType);
using (var writer = new DataStreamWriter(buff.Length, Allocator.Temp))
{
writer.Write(buff);
m_Connection.Send(m_Driver, writer);
}
}
else if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
var value = stream.ReadBytesAsArray(ref readerCtx, stream.Length);
CustomType ct = cts.DeSerialize(value);
Debug.Log("Got the value = " + ct.val + " back from the server");
m_Done = true;
m_Connection.Disconnect(m_Driver);
m_Connection = default(NetworkConnection);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client got disconnected from server");
m_Connection = default(NetworkConnection);
}
}
}
void Update()
{
ClientJobHandle.Complete();
var job = new ClientUpdateJob
{
driver = m_Driver,
pipeline = m_Pipeline,
connection = m_Connection,
done = m_Done
};
ClientJobHandle = m_Driver.ScheduleUpdate();
ClientJobHandle = job.Schedule(ClientJobHandle);
}
// Non-blocking; ticks ping state machine once
// 3+ ticks required to do a full cycle (connect, send, receive + disconnect)
void RunPingJob()
{
// Wait for existing job to finish
updateHandle.Complete();
// Write stats from last job
Stats.AddEntry(m_NumPings[0], m_LastPing[0]);
// Disconnect if we exceeded our disconnect timeout
if (m_ClientToServerConnection.Length > 0 &&
m_ClientToServerConnection[0].IsCreated &&
m_NumPings[0] == m_PendingPings[0].id &&
(Time.fixedTime - m_PendingPings[0].time > k_PingTimeoutMs))
{
Debug.Log($"Resetting connection to ping server due to ping timeout (time waiting for response > {k_PingTimeoutMs} ms).");
m_ClientToServerConnection[0].Disconnect(m_ClientDriver);
m_ClientToServerConnection[0] = default(NetworkConnection);
}
// Schedule driver update
updateHandle = m_ClientDriver.ScheduleUpdate();
var pingJob = new PingJob
{
driver = m_ClientDriver,
connection = m_ClientToServerConnection,
serverEp = m_ServerEndpoint,
pendingPings = m_PendingPings,
numPings = m_NumPings,
lastPing = m_LastPing
};
// Schedule an update chain with the driver update followed by the ping job
updateHandle = pingJob.Schedule(updateHandle);
JobHandle.ScheduleBatchedJobs();
}
void Update()
{
clientJobHandle.Complete();
ClientUpdateJob job = new ClientUpdateJob
{
driver = m_Driver,
connection = m_Connection,
done = m_Done,
unreliablePipeline = m_Unreliable_Pipeline,
reliablePipeline = m_Reliable_Pipeline
};
clientJobHandle = m_Driver.ScheduleUpdate();
//clientJobHandle = job.Schedule(clientJobHandle);
}
