public void DisconnectTimeoutOnServer()
{
using (var host = new LocalDriverHelper(default(NetworkEndPoint),
new NetworkConfigParameter {
disconnectTimeout = 40
}))
using (var client = new LocalNetworkDriver(new NetworkConfigParameter {
disconnectTimeout = 40
}))
{
NetworkConnection id;
NetworkEvent.Type popEvent = NetworkEvent.Type.Empty;
DataStreamReader reader;
host.Host();
client.Connect(host.Address);
client.ScheduleUpdate().Complete();
host.Assert_GotConnectionRequest(client.LocalEndPoint(), true);
var stream = new DataStreamWriter(100, Allocator.Persistent);
for (int i = 0; i < 100; i++)
{
stream.Write((byte)i);
}
// Host sends stuff but gets nothing back, until disconnect timeout happens
var timeout = m_timer.ElapsedMilliseconds + 100;
while (m_timer.ElapsedMilliseconds < timeout)
{
host.m_LocalDriver.Send(host.ClientConnections[0], stream);
popEvent = host.m_LocalDriver.PopEvent(out id, out reader);
if (popEvent != NetworkEvent.Type.Empty)
{
break;
}
host.Update();
}
stream.Dispose();
Assert.AreEqual(NetworkEvent.Type.Disconnect, popEvent);
}
}
public void SendReceiveInParallelJobWorks()
{
NativeArray <NetworkConnection> serverToClient;
using (var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (var clientDriver0 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (var clientDriver1 = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
}))
using (serverToClient = new NativeArray <NetworkConnection>(2, Allocator.Persistent))
{
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
var clientToServer0 = clientDriver0.Connect(serverDriver.LocalEndPoint());
var clientToServer1 = clientDriver1.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver0, serverDriver, clientToServer0);
serverToClient[0] = serverDriver.Accept();
Assert.IsTrue(serverToClient[0].IsCreated);
WaitForConnected(clientDriver1, serverDriver, clientToServer1);
serverToClient[1] = serverDriver.Accept();
Assert.IsTrue(serverToClient[1].IsCreated);
clientToServer0.Send(clientDriver0, strmWriter);
clientToServer1.Send(clientDriver1, strmWriter);
clientDriver0.ScheduleUpdate().Complete();
clientDriver1.ScheduleUpdate().Complete();
var sendRecvJob = new SendReceiveParallelJob {
driver = serverDriver.ToConcurrent(), connections = serverToClient
};
var jobHandle = serverDriver.ScheduleUpdate();
jobHandle = sendRecvJob.Schedule(serverToClient.Length, 1, jobHandle);
serverDriver.ScheduleUpdate(jobHandle).Complete();
AssertDataReceived(serverDriver, serverToClient, clientDriver0, clientToServer0, 43, true);
AssertDataReceived(serverDriver, serverToClient, clientDriver1, clientToServer1, 43, true);
}
}
public void Execute()
{
if (!connection[0].IsCreated)
{
if (isDone[0] != 1)
{
Debug.Log("Something went wrong during connection.");
}
return;
}
DataStreamReader stream;
NetworkEvent.Type cmd;
while ((cmd = connection[0].PopEvent(driver, out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == 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);
connection[0].Send(driver, writer);
}
}
else if (cmd == NetworkEvent.Type.Data)
{
var readerCtx = default(DataStreamReader.Context);
uint value = stream.ReadUInt(ref readerCtx);
Debug.Log("Got the value = " + value + " back from the server");
isDone[0] = 1;
connection[0].Disconnect(driver);
connection[0] = default;
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client is disconnected from the server");
connection[0] = default;
}
}
}
public void Serialize(int networkId, ref ShipSnapshotData baseline, DataStreamWriter writer, NetworkCompressionModel compressionModel)
{
changeMask0 = (PlayerIdComponentDataPlayerId != baseline.PlayerIdComponentDataPlayerId) ? 1u : 0;
changeMask0 |= (ShipStateComponentDataState != baseline.ShipStateComponentDataState) ? (1u << 1) : 0;
changeMask0 |= (RotationValue != baseline.RotationValue) ? (1u << 2) : 0;
changeMask0 |= (TranslationValueX != baseline.TranslationValueX ||
TranslationValueY != baseline.TranslationValueY) ? (1u << 3) : 0;
changeMask0 |= (VelocityValueX != baseline.VelocityValueX ||
VelocityValueY != baseline.VelocityValueY) ? (1u << 4) : 0;
writer.WritePackedUIntDelta(changeMask0, baseline.changeMask0, compressionModel);
bool isPredicted = GetPlayerIdComponentDataPlayerId() == networkId;
writer.WritePackedUInt(isPredicted?1u:0, compressionModel);
if ((changeMask0 & (1 << 2)) != 0)
{
writer.WritePackedIntDelta(RotationValue, baseline.RotationValue, compressionModel);
}
if ((changeMask0 & (1 << 3)) != 0)
{
writer.WritePackedIntDelta(TranslationValueX, baseline.TranslationValueX, compressionModel);
writer.WritePackedIntDelta(TranslationValueY, baseline.TranslationValueY, compressionModel);
}
if (isPredicted)
{
if ((changeMask0 & (1 << 0)) != 0)
{
writer.WritePackedIntDelta(PlayerIdComponentDataPlayerId, baseline.PlayerIdComponentDataPlayerId, compressionModel);
}
if ((changeMask0 & (1 << 4)) != 0)
{
writer.WritePackedIntDelta(VelocityValueX, baseline.VelocityValueX, compressionModel);
writer.WritePackedIntDelta(VelocityValueY, baseline.VelocityValueY, compressionModel);
}
}
if (!isPredicted)
{
if ((changeMask0 & (1 << 1)) != 0)
{
writer.WritePackedIntDelta(ShipStateComponentDataState, baseline.ShipStateComponentDataState, compressionModel);
}
}
}
public static unsafe void SendProtocolVersion(DynamicBuffer <OutgoingRpcDataStreamBufferComponent> buffer, NetworkProtocolVersion version)
{
bool dynamicAssemblyList = (version.RpcCollectionVersion == 0);
int msgHeaderLen = dynamicAssemblyList ? 10 : 4;
DataStreamWriter writer = new DataStreamWriter(UnsafeUtility.SizeOf <NetworkProtocolVersion>() + msgHeaderLen + 1, Allocator.Temp);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (buffer.Length != 0)
{
throw new InvalidOperationException("Protocol version must be the very first RPC sent");
}
#endif
writer.WriteByte((byte)NetworkStreamProtocol.Rpc);
if (dynamicAssemblyList)
{
writer.WriteULong(0);
}
else
{
writer.WriteUShort(ushort.MaxValue);
}
var lenWriter = writer;
writer.WriteUShort((ushort)0);
writer.WriteInt(version.NetCodeVersion);
writer.WriteInt(version.GameVersion);
if (dynamicAssemblyList)
{
writer.WriteULong(0);
writer.WriteULong(0);
}
else
{
writer.WriteULong(version.RpcCollectionVersion);
writer.WriteULong(version.ComponentCollectionVersion);
}
lenWriter.WriteUShort((ushort)(writer.Length - msgHeaderLen - 1));
var prevLen = buffer.Length;
buffer.ResizeUninitialized(buffer.Length + writer.Length);
byte *ptr = (byte *)buffer.GetUnsafePtr();
ptr += prevLen;
UnsafeUtility.MemCpy(ptr, writer.AsNativeArray().GetUnsafeReadOnlyPtr(), writer.Length);
}
public void Execute()
{
if (!connection[0].IsCreated)
{
if (done[0] != 1)
{
Debug.Log("Something went wrong during connect");
}
return;
}
DataStreamReader stream;
NetworkEvent.Type cmd;
while ((cmd = connection[0].PopEvent(driver, out stream)) != NetworkEvent.Type.Empty)
{
if (cmd == NetworkEvent.Type.Connect)
{
Debug.Log("We are now connected to the server");
string TestMessage = "Test";
DataStreamWriter writer = driver.BeginSend(connection[0]);
writer.WriteString(TestMessage);
driver.EndSend(writer);
}
else if (cmd == NetworkEvent.Type.Data)
{
string value = stream.ReadString().ToString();
Debug.Log("Received: " + value);
done[0] = 1;
connection[0].Disconnect(driver);
connection[0] = default(NetworkConnection);
}
else if (cmd == NetworkEvent.Type.Disconnect)
{
Debug.Log("Client got disconnected from server");
connection[0] = default(NetworkConnection);
}
}
}
public unsafe int Serialize(int serializer, ArchetypeChunk chunk, int startIndex, uint currentTick,
Entity *currentSnapshotEntity, void *currentSnapshotData,
GhostSystemStateComponent *ghosts, NativeArray <Entity> ghostEntities,
NativeArray <int> baselinePerEntity, NativeList <SnapshotBaseline> availableBaselines,
DataStreamWriter dataStream, NetworkCompressionModel compressionModel)
{
switch (serializer)
{
case 0:
{
return(GhostSendSystem <GhostSerializerCollection> .InvokeSerialize(m_CubeGhostSerializer, serializer,
chunk, startIndex, currentTick, currentSnapshotEntity, (CubeSnapshotData *)currentSnapshotData,
ghosts, ghostEntities, baselinePerEntity, availableBaselines,
dataStream, compressionModel));
}
default:
throw new ArgumentException("Invalid serializer type");
}
}
public override void Write(DataStreamWriter writer, TransformRPCData data)
{
var position = data.Target.position;
var rotation = data.Target.rotation;
byte[] buff = new byte[sizeof(float) * 7];
Buffer.BlockCopy(BitConverter.GetBytes(position.x), 0, buff, 0 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(position.y), 0, buff, 1 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(position.z), 0, buff, 2 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.x), 0, buff, 3 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.y), 0, buff, 4 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.z), 0, buff, 5 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.w), 0, buff, 6 * sizeof(float), sizeof(float));
Data.Position = position;
Data.Rotation = rotation;
writer.Write(buff);
}
public void ReadIntoExistingByteArray()
{
var byteArray = new NativeArray <byte>(100, Allocator.Temp);
DataStreamWriter dataStream;
dataStream = new DataStreamWriter(3, Allocator.Temp);
{
dataStream.WriteByte((byte)'a');
dataStream.WriteByte((byte)'b');
dataStream.WriteByte((byte)'c');
var reader = new DataStreamReader(dataStream.AsNativeArray());
reader.ReadBytes(byteArray.GetSubArray(0, dataStream.Length));
reader = new DataStreamReader(dataStream.AsNativeArray());
for (int i = 0; i < reader.Length; ++i)
{
Assert.AreEqual(byteArray[i], reader.ReadByte());
}
}
}
public void CreateStreamWithSourceByteArray()
{
byte[] byteArray = new byte[100];
byteArray[0] = (byte)'a';
byteArray[1] = (byte)'b';
byteArray[2] = (byte)'c';
DataStreamWriter dataStream;
using (dataStream = new DataStreamWriter(byteArray.Length, Allocator.Persistent))
{
dataStream.Write(byteArray, byteArray.Length);
var reader = new DataStreamReader(dataStream, 0, byteArray.Length);
var readerCtx = default(DataStreamReader.Context);
for (int i = 0; i < reader.Length; ++i)
{
Assert.AreEqual(byteArray[i], reader.ReadByte(ref readerCtx));
}
}
}
protected override void OnCreate()
{
base.OnCreate();
m_SerializeLookup = new Dictionary <Entity, ReferencableSerializeClientData>(32);
m_ConnectionGroup = GetEntityQuery(new EntityQueryDesc
{
All = new ComponentType[] { typeof(NetworkStreamConnection), typeof(NetworkSnapshotAckComponent), /*typeof(NetworkStreamInGame)*/ }
});
m_ConnectionWithoutSnapshotBufferGroup = GetEntityQuery(new EntityQueryDesc
{
All = new ComponentType[] { typeof(NetworkStreamConnection), /* typeof(NetworkStreamInGame)*/ },
None = new ComponentType[] { typeof(ClientSnapshotBuffer) }
});
m_ServerSimulationSystemGroup = World.GetOrCreateSystem <ServerSimulationSystemGroup>();
m_ReceiveSystem = World.GetOrCreateSystem <NetworkStreamReceiveSystem>();
m_CreateSnapshotSystem = World.GetOrCreateSystem <CreateSnapshotSystem>();
m_DataStream = new DataStreamWriter(32_768, Allocator.Persistent);
}
public void SendRPC(NetAsset netAsset, string methodName, object[] args)
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
throw new InvalidOperationException($"Cannot send rpc {methodName}: not connected");
}
DataStreamWriter streamWriter = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
streamWriter.WriteInt(Commands.NetAssetRPC);
streamWriter.WriteFloat(Server.Time);
streamWriter.WriteInt(netAsset.NetID);
netAsset.SerializeRPC(ref streamWriter, methodName, args);
_clientDriver.EndSend(streamWriter);
DataSent?.Invoke(streamWriter.Length);
}
public void ToStream(ref DataStreamWriter writer)
{
var lengthValue = QueryHeader.ToStream(ref writer);
var start = (ushort)writer.Length;
var chunkValue = writer.WriteNetworkByteOrder((uint)0);
var chunkStart = writer.Length;
ServerInfoData.ToStream(ref writer);
ChunkLen = (uint)(writer.Length - chunkStart);
QueryHeader.Length = (ushort)(writer.Length - start);
lengthValue.Update(QueryHeader.Length);
chunkValue.Update(ChunkLen);
var length = (ushort)System.Net.IPAddress.HostToNetworkOrder((short)QueryHeader.Length);
var chunkLen = (uint)System.Net.IPAddress.HostToNetworkOrder((int)ChunkLen);
}
public void CopyToByteArrayWithOffset()
{
byte[] byteArray = new byte[100];
using (var dataStream = new DataStreamWriter(100, Allocator.Persistent))
{
dataStream.Write((byte)'a');
dataStream.Write((byte)'b');
dataStream.Write((byte)'c');
dataStream.Write((byte)'d');
dataStream.Write((byte)'e');
dataStream.Write((byte)'f');
dataStream.CopyTo(2, 3, ref byteArray);
Assert.AreEqual(byteArray[0], (byte)'c');
Assert.AreEqual(byteArray[1], (byte)'d');
Assert.AreEqual(byteArray[2], (byte)'e');
Assert.AreNotEqual(byteArray[3], (byte)'f');
}
}
public static void Serialize(PilotSettings serverVariables, ref DataStreamWriter writer)
{
var varibles = typeof(PilotSettings).GetFields();
for (int i = 0; i < varibles.Length; i++)
{
if (varibles[i].FieldType == typeof(float))
{
writer.WriteFloat((float)typeof(PilotSettings).GetField(varibles[i].Name).GetValue(serverVariables));
}
}
var speedVaribles = typeof(PilotSettings.Speeds).GetFields();
for (int i = 0; i < speedVaribles.Length; i++)
{
if (speedVaribles[i].FieldType == typeof(float))
{
writer.WriteFloat((float)typeof(PilotSettings.Speeds).GetField(speedVaribles[i].Name).GetValue(serverVariables.speeds));
}
}
}
public void ReadWritePackedStringDelta()
{
var dataStream = new DataStreamWriter(300 * 4, Allocator.Temp);
var compressionModel = new NetworkCompressionModel(Allocator.Temp);
NativeString64 src = new NativeString64("This is a string");
NativeString64 baseline = new NativeString64("This is another string");
dataStream.WritePackedStringDelta(src, baseline, compressionModel);
dataStream.Flush();
//Assert.LessOrEqual(dataStream.Length, src.LengthInBytes+2);
var reader = new DataStreamReader(dataStream, 0, dataStream.Length);
DataStreamReader.Context ctx = default;
var dst = reader.ReadPackedStringDelta(ref ctx, baseline, compressionModel);
Assert.AreEqual(src, dst);
ctx = default;
}
public override void Write(DataStreamWriter writer, SpawnRPCData data)
{
writer.Write(data.InstanceId);
writer.Write(data.PrefabId);
writer.Write((int)data.Ownership);
var position = data.Position;
var rotation = data.Rotation;
byte[] buff = new byte[sizeof(float) * 7];
Buffer.BlockCopy(BitConverter.GetBytes(position.x), 0, buff, 0 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(position.y), 0, buff, 1 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(position.z), 0, buff, 2 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.x), 0, buff, 3 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.y), 0, buff, 4 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.z), 0, buff, 5 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.w), 0, buff, 6 * sizeof(float), sizeof(float));
writer.Write(buff);
}
public void SendGameAction(GameAction gameAction, GameAction.IParameters parameters)
{
if (State == ClientState.Debug)
{
return;
}
if (State != ClientState.Connected)
{
throw new InvalidOperationException($"Cannot send game action {gameAction}: not connected");
}
DataStreamWriter streamWriter = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
streamWriter.WriteInt(Commands.GameAction);
streamWriter.WriteInt(GameActionManager.Instance.GetID(gameAction));
streamWriter.WriteInt(ActorNumber);
streamWriter.WriteFloat(Server.Time);
gameAction.SerializeParameters(ref streamWriter, parameters);
_clientDriver.EndSend(streamWriter);
DataSent?.Invoke(streamWriter.Length);
}
public void TestSignaturesV3_1_X()
{
string tableName = "output_table";
WithTable(
_spark,
new string[] { tableName },
() =>
{
using var tempDirectory = new TemporaryDirectory();
var intMemoryStream = new MemoryStream <int>(_spark);
DataStreamWriter dsw = intMemoryStream
.ToDF()
.WriteStream()
.Format("parquet")
.Option("checkpointLocation", tempDirectory.Path);
StreamingQuery sq = dsw.ToTable(tableName);
sq.Stop();
});
}
internal void SendExistingPlayersTo(NetworkConnection source)
{
for (int i = 0; i < m_Connections.Length; ++i)
{
//skip message for source client
if (m_Connections[i] == source)
{
continue;
}
int index = GetIndexForConnection(m_Connections[i]);
if (index != -1)
{
using (var writer = new DataStreamWriter(8, Allocator.Temp)) {
writer.Write((uint)GameEvent.PLAYER_JOINED);
writer.Write((uint)index);
source.Send(m_Driver, writer);
}
}
}
}
// Client requesting to spawn
public void RequestSpawn(int prefabId, ClientBehaviour client, Vector3 position, Quaternion rotation)
{
var writer = new DataStreamWriter(36, Allocator.Temp);
writer.Write(SpawnRequestId);
writer.Write(prefabId);
byte[] buff = new byte[sizeof(float) * 7];
Buffer.BlockCopy(BitConverter.GetBytes(position.x), 0, buff, 0 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(position.y), 0, buff, 1 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(position.z), 0, buff, 2 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.x), 0, buff, 3 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.y), 0, buff, 4 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.z), 0, buff, 5 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(rotation.w), 0, buff, 6 * sizeof(float), sizeof(float));
writer.Write(buff);
client.Send(writer);
}
public IEnumerator ServerAndClient_SendMessageWithoutReadingIt_GivesErrorOnDriverUpdate()
{
SetupServerAndClientAndConnectThem(0);
//send data from client
DataStreamWriter m_OutStream = new DataStreamWriter(16, Allocator.Persistent);
m_OutStream.Clear();
m_OutStream.Write(SharedConstants.ping);
clientToServerConnection.Send(client_driver, m_OutStream);
m_OutStream.Dispose();
server_driver.ScheduleUpdate().Complete();
client_driver.ScheduleUpdate().Complete();
LogAssert.Expect(LogType.Error, "Resetting event queue with pending events (Count=1, ConnectionID=0) Listening: 1");
server_driver.ScheduleUpdate().Complete();
DisconnectAndCleanup();
yield return(null);
}
public override DataStreamWriter Write(DataStreamWriter writer)
{
if (InstanceId != null)
{
writer.Write(InstanceId.Value);
}
byte[] buff = new byte[sizeof(float) * 7];
Buffer.BlockCopy(BitConverter.GetBytes(transform.position.x), 0, buff, 0 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(transform.position.y), 0, buff, 1 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(transform.position.z), 0, buff, 2 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(transform.rotation.x), 0, buff, 3 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(transform.rotation.y), 0, buff, 4 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(transform.rotation.z), 0, buff, 5 * sizeof(float), sizeof(float));
Buffer.BlockCopy(BitConverter.GetBytes(transform.rotation.w), 0, buff, 6 * sizeof(float), sizeof(float));
writer.Write(buff);
return(writer);
}
public static unsafe void SendProtocolVersion(DynamicBuffer <OutgoingRpcDataStreamBufferComponent> buffer, NetworkProtocolVersion version)
{
DataStreamWriter writer = new DataStreamWriter(UnsafeUtility.SizeOf <NetworkProtocolVersion>() + 2 + 1, Allocator.Temp);
#if ENABLE_UNITY_COLLECTIONS_CHECKS
if (buffer.Length != 0)
{
throw new InvalidOperationException("Protocol version must be the very first RPC sent");
}
#endif
writer.Write((byte)NetworkStreamProtocol.Rpc);
writer.Write(ushort.MaxValue);
writer.Write(version.NetCodeVersion);
writer.Write(version.GameVersion);
writer.Write(version.RpcCollectionVersion);
var prevLen = buffer.Length;
buffer.ResizeUninitialized(buffer.Length + writer.Length);
byte *ptr = (byte *)buffer.GetUnsafePtr();
ptr += prevLen;
UnsafeUtility.MemCpy(ptr, writer.GetUnsafeReadOnlyPtr(), writer.Length);
}
public void Serialize(int networkId, ref BulletSnapshotData baseline, DataStreamWriter writer, NetworkCompressionModel compressionModel)
{
changeMask0 = (PlayerIdComponentDataPlayerId != baseline.PlayerIdComponentDataPlayerId) ? 1u : 0;
changeMask0 |= (RotationValue != baseline.RotationValue) ? (1u << 1) : 0;
changeMask0 |= (TranslationValueX != baseline.TranslationValueX ||
TranslationValueY != baseline.TranslationValueY) ? (1u << 2) : 0;
writer.WritePackedUIntDelta(changeMask0, baseline.changeMask0, compressionModel);
if ((changeMask0 & (1 << 0)) != 0)
{
writer.WritePackedIntDelta(PlayerIdComponentDataPlayerId, baseline.PlayerIdComponentDataPlayerId, compressionModel);
}
if ((changeMask0 & (1 << 1)) != 0)
{
writer.WritePackedIntDelta(RotationValue, baseline.RotationValue, compressionModel);
}
if ((changeMask0 & (1 << 2)) != 0)
{
writer.WritePackedIntDelta(TranslationValueX, baseline.TranslationValueX, compressionModel);
writer.WritePackedIntDelta(TranslationValueY, baseline.TranslationValueY, compressionModel);
}
}
public void Serialize(int networkId, ref GhostSnapshotData baseline, ref DataStreamWriter writer, NetworkCompressionModel compressionModel)
{
#region __GHOST_CALCULATE_CHANGE_MASK_ZERO__
changeMask__GHOST_MASK_BATCH__ = (__GHOST_FIELD_NAME__X != baseline.__GHOST_FIELD_NAME__X ||
__GHOST_FIELD_NAME__Y != baseline.__GHOST_FIELD_NAME__Y ||
__GHOST_FIELD_NAME__Z != baseline.__GHOST_FIELD_NAME__Z) ? 1u : 0;
#endregion
#region __GHOST_CALCULATE_CHANGE_MASK__
changeMask__GHOST_MASK_BATCH__ |= (__GHOST_FIELD_NAME__X != baseline.__GHOST_FIELD_NAME__X ||
__GHOST_FIELD_NAME__Y != baseline.__GHOST_FIELD_NAME__Y ||
__GHOST_FIELD_NAME__Z != baseline.__GHOST_FIELD_NAME__Z) ? (1u << __GHOST_MASK_INDEX__) : 0;
#endregion
#region __GHOST_WRITE__
if ((changeMask__GHOST_MASK_BATCH__ & (1 << __GHOST_MASK_INDEX__)) != 0)
{
writer.WritePackedFloatDelta(__GHOST_FIELD_NAME__X, baseline.__GHOST_FIELD_NAME__X, compressionModel);
writer.WritePackedFloatDelta(__GHOST_FIELD_NAME__Y, baseline.__GHOST_FIELD_NAME__Y, compressionModel);
writer.WritePackedFloatDelta(__GHOST_FIELD_NAME__Z, baseline.__GHOST_FIELD_NAME__Z, compressionModel);
}
#endregion
}
public void ReadIntoExistingByteArray()
{
byte[] byteArray = new byte[100];
DataStreamWriter dataStream;
using (dataStream = new DataStreamWriter(3, Allocator.Persistent))
{
dataStream.Write((byte)'a');
dataStream.Write((byte)'b');
dataStream.Write((byte)'c');
var reader = new DataStreamReader(dataStream, 0, dataStream.Length);
var readerCtx = default(DataStreamReader.Context);
reader.ReadBytesIntoArray(ref readerCtx, ref byteArray, dataStream.Length);
readerCtx = default(DataStreamReader.Context);
for (int i = 0; i < reader.Length; ++i)
{
Assert.AreEqual(byteArray[i], reader.ReadByte(ref readerCtx));
}
}
}
public void ReceiveInJobWorks()
{
var serverDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
serverDriver.Bind(IPCManager.Instance.CreateEndPoint());
serverDriver.Listen();
var clientDriver = new LocalNetworkDriver(new NetworkDataStreamParameter {
size = 64
});
var clientToServer = clientDriver.Connect(serverDriver.LocalEndPoint());
WaitForConnected(clientDriver, serverDriver, clientToServer);
var strmWriter = new DataStreamWriter(4, Allocator.Temp);
strmWriter.Write(42);
clientToServer.Send(clientDriver, strmWriter);
strmWriter.Dispose();
clientDriver.ScheduleUpdate().Complete();
var serverToClient = new NativeArray <NetworkConnection>(1, Allocator.TempJob);
var result = new NativeArray <int>(1, Allocator.TempJob);
var recvJob = new ReceiveJob {
driver = serverDriver, connections = serverToClient, result = result
};
Assert.AreNotEqual(42, result[0]);
var acceptJob = new AcceptJob {
driver = serverDriver, connections = serverToClient
};
recvJob.Schedule(serverDriver.ScheduleUpdate(acceptJob.Schedule())).Complete();
Assert.AreEqual(42, result[0]);
result.Dispose();
serverToClient.Dispose();
clientDriver.Dispose();
serverDriver.Dispose();
}
public unsafe void Execute(Entity entity, int index, [ReadOnly] ref PlayerStateComponentData state)
{
// FIXME: ack and sending command stream should be handled by a different system
DataStreamWriter writer = new DataStreamWriter(128, Allocator.Temp);
var buffer = cmdBuffer[entity];
var ack = ackSnapshot[entity];
writer.Write((byte)NetworkStreamProtocol.Command);
writer.Write(ack.LastReceivedSnapshotByLocal);
writer.Write(ack.ReceivedSnapshotByLocalMask);
writer.Write(localTime);
writer.Write(ack.LastReceivedRemoteTime - (localTime - ack.LastReceiveTimestamp));
if (state.PlayerShip == Entity.Null)
{
if (shoot != 0)
{
rpcQueue.Schedule(rpcBuffer[entity], new RpcSpawn());
}
}
else
{
writer.Write(inputTargetTick);
writer.Write(left);
writer.Write(right);
writer.Write(thrust);
writer.Write(shoot);
// If ship, store commands in network command buffer
/*input = new PlayerInputComponentData(left, right, thrust, shoot);*/
// FIXME: when destroying the ship is in a command buffer this no longer works
if (shipState.Exists(state.PlayerShip)) // There might be a pending set to null
{
shipState[state.PlayerShip] = new ShipStateComponentData(thrust, true);
}
}
buffer.ResizeUninitialized(writer.Length);
byte *ptr = (byte *)buffer.GetUnsafePtr();
UnsafeUtility.MemCpy(buffer.GetUnsafePtr(), writer.GetUnsafeReadOnlyPtr(), writer.Length);
}
public SoakClient(double sendInterval, int packetSize, int duration)
{
DriverHandle = new UdpCNetworkDriver(new INetworkParameter[0]);
if (packetSize > NetworkParameterConstants.MTU)
{
Debug.LogWarning("Trunkating packet size to MTU");
packetSize = NetworkParameterConstants.MTU;
}
else if (packetSize < SoakMessage.HeaderLength)
{
Debug.LogWarning("Packet size was to small resizing to at least SoakMessage HeaderSize");
packetSize = SoakMessage.HeaderLength;
}
var payloadSize = packetSize - SoakMessage.HeaderLength;
SoakClientStreamWriter = new DataStreamWriter(packetSize, Allocator.Persistent);
PendingSoakMessages = new NativeArray <SoakMessage>(64, Allocator.Persistent);
ConnectionHandle = new NativeArray <NetworkConnection>(1, Allocator.Persistent);
SoakJobDataPacket = new NativeArray <byte>(payloadSize, Allocator.Persistent);
var random = new byte[payloadSize];
Random r = new Random();
r.NextBytes(random);
SoakJobDataPacket.CopyFrom(random);
SoakJobContextsHandle = new NativeArray <SoakJobContext>(1, Allocator.Persistent);
var context = new SoakJobContext
{
Duration = duration,
PacketSize = packetSize,
SendInterval = sendInterval
};
SoakJobContextsHandle[0] = context;
SoakStatisticsHandle = new NativeArray <SoakStatisticsPoint>(1, Allocator.Persistent);
SoakStatisticsHandle[0] = new SoakStatisticsPoint();
}
