public void ReadWritePackedUIntWithDeferred()
{
using (var compressionModel = new NetworkCompressionModel(Allocator.Persistent))
{
var dataStream = new DataStreamWriter(300 * 4, Allocator.Temp);
uint base_val = 2000;
uint count = 277;
var def = dataStream;
dataStream.WriteInt((int)0);
for (uint i = 0; i < count; ++i)
{
dataStream.WritePackedUInt(base_val + i, compressionModel);
}
dataStream.Flush();
def.WriteInt(1979);
def = dataStream;
dataStream.WriteInt((int)0);
def.WriteInt(1979);
dataStream.Flush();
var reader = new DataStreamReader(dataStream.AsNativeArray());
Assert.AreEqual(1979, reader.ReadInt());
for (uint i = 0; i < count; ++i)
{
var val = reader.ReadPackedUInt(compressionModel);
Assert.AreEqual(base_val + i, val);
}
Assert.AreEqual(1979, reader.ReadInt());
}
}
public void WriteOutOfBounds()
{
var dataStream = new DataStreamWriter(9, Allocator.Temp);
Assert.IsTrue(dataStream.WriteInt(42));
Assert.AreEqual(4, dataStream.Length);
Assert.IsTrue(dataStream.WriteInt(42));
Assert.AreEqual(8, dataStream.Length);
Assert.IsFalse(dataStream.HasFailedWrites);
Assert.IsFalse(dataStream.WriteInt(42));
Assert.AreEqual(8, dataStream.Length);
Assert.IsTrue(dataStream.HasFailedWrites);
Assert.IsFalse(dataStream.WriteShort(42));
Assert.AreEqual(8, dataStream.Length);
Assert.IsTrue(dataStream.HasFailedWrites);
Assert.IsTrue(dataStream.WriteByte(42));
Assert.AreEqual(9, dataStream.Length);
Assert.IsTrue(dataStream.HasFailedWrites);
Assert.IsFalse(dataStream.WriteByte(42));
Assert.AreEqual(9, dataStream.Length);
Assert.IsTrue(dataStream.HasFailedWrites);
}
public override DataStreamWriter WritePacket(DataStreamWriter writer)
{
writer.WriteInt(ID);
writer.WriteInt(playerID.Value);
writer.WriteInt(playerCharacterID.Value);
return(writer);
}
private void OnSceneLoaded(Scene scene, LoadSceneMode loadSceneMode)
{
DataStreamWriter writer = _clientDriver.BeginSend(_reliablePipeline, _clientToServerConnection);
writer.WriteInt(Commands.RequestSpawnMessage);
writer.WriteInt(1);
writer.WriteInt(scene.buildIndex);
_clientDriver.EndSend(writer);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt((int)(movement.x * 100));
writer.WriteInt((int)(movement.y * 100));
writer.WriteInt(jumping ? 1 : 0);
head.Serialize(ref writer, 10000);
leftHand.Serialize(ref writer, 1000);
rightHand.Serialize(ref writer, 1000);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(checkTick);
writer.WriteInt(renderTick);
writer.WriteInt((int)(moveYaw * 10));
writer.WriteInt((int)(moveMagnitude * 100));
writer.WriteUInt((uint)buttons.flags);
writer.WriteFloat(lookYaw);
writer.WriteFloat(lookPitch);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteShort(skillId);
writer.WriteShort(skill2Id);
writer.WriteShort(skill3Id);
writer.WriteShort(skill4Id);
writer.WriteInt((int)characterId);
writer.WriteInt((int)skinId);
writer.WriteString(userId);
}
private static void SerializeNetAsset(NetAsset netAsset, ref DataStreamWriter streamWriter, bool fullLoad)
{
streamWriter.WriteInt(netAsset.NetID);
DataStreamWriter sizeWriter = streamWriter;
streamWriter.WriteInt(0);
int length = streamWriter.Length;
netAsset.Serialize(ref streamWriter, fullLoad);
sizeWriter.WriteInt(streamWriter.Length - length);
}
private static void WriteNetObject(NetObject netObject, ref DataStreamWriter streamWriter)
{
streamWriter.WriteInt(netObject.ID);
DataStreamWriter sizeWriter = streamWriter;
streamWriter.WriteInt(0);
int length = streamWriter.Length;
netObject.Serialize(ref streamWriter, false);
sizeWriter.WriteInt(streamWriter.Length - length);
}
public override DataStreamWriter WritePacket(DataStreamWriter writer)
{
writer.WriteInt(ID);
writer.WriteInt(playerID.Value);
writer.WriteInt(queuedActionIDs.Items.Count);
for (int i = 0; i < queuedActionIDs.Items.Count; i++)
{
writer.WriteInt(queuedActionIDs.Items[i]);
}
queuedActionIDs.Items.Clear();
return(writer);
}
protected override void Serialize(ref DataStreamWriter writer, byte dirtyMask)
{
if (IsDirtyAt(dirtyMask, 0))
{
writer.WriteInt(_paramBytes.Length);
writer.WriteBytes(new NativeArray <byte>(_paramBytes, Allocator.Temp));
}
if (IsDirtyAt(dirtyMask, 1))
{
writer.WriteInt(_currentStateHash);
writer.WriteFloat(_currentEnterTime);
}
}
private static void WriteNetObject(NetObject netObject, ref DataStreamWriter streamWriter)
{
if (!netObject.IsMine)
{
return;
}
streamWriter.WriteInt(netObject.ID);
DataStreamWriter sizeWriter = streamWriter;
streamWriter.WriteInt(0);
int length = streamWriter.Length;
netObject.Serialize(ref streamWriter, false, b => b.HasAuthority);
sizeWriter.WriteInt(streamWriter.Length - length);
}
public void Serialize(ref DataStreamWriter writer)
{
new Message(id, messageType).Serialize(ref writer);
writer.WriteInt(playerID);
writer.WriteUShort(value);
}
public void AcceptPlayer(int actorNumber)
{
if (State == ServerState.Debug)
{
return;
}
if (State != ServerState.Started)
{
throw new InvalidOperationException("Cannot accept player: Server not running");
}
for (var i = 0; i < _connections.Length; i++)
{
NetworkConnection connection = _connections[i];
if (connection.InternalId != actorNumber)
{
continue;
}
Debug.Log($"Accepting player of client {actorNumber}");
var connections = new NativeList <NetworkConnection>(1, Allocator.Temp)
{
connection
};
DataStreamWriter writer = _serverDriver.BeginSend(_reliablePipeline, connection);
writer.WriteInt(Commands.AcceptPlayer);
_serverDriver.EndSend(writer);
SendNetAssetUpdate(true, connections);
connections.Dispose();
PlayerAccepted?.Invoke(actorNumber);
return;
}
Debug.LogWarning($"Cannot accept player of client {actorNumber}: No connection found");
}
public override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteInt(PlayerID);
writer.WriteUInt(PlayerColour);
}
private byte[] SerializeParams()
{
var writer = new DataStreamWriter(1000, Allocator.Temp);
for (var i = 0; i < _animator.parameterCount; i++)
{
switch (_animatorControllerParameters[i].type)
{
case AnimatorControllerParameterType.Float:
writer.WriteFloat(_animator.GetFloat(_animatorControllerParameters[i].nameHash));
break;
case AnimatorControllerParameterType.Int:
writer.WriteInt(_animator.GetInteger(_animatorControllerParameters[i].nameHash));
break;
case AnimatorControllerParameterType.Bool:
case AnimatorControllerParameterType.Trigger:
writer.WriteBool(_animator.GetBool(_animatorControllerParameters[i].nameHash));
break;
default:
throw new ArgumentOutOfRangeException();
}
}
return(writer.AsNativeArray().ToArray());
}
public static void Send(ClientMessage clientMessageType, ClientBehaviour sender)
{
DataStreamWriter writer = sender.m_Driver.BeginSend(sender.m_Connection);
writer.WriteByte((byte)clientMessageType);
Debug.LogError("Player_id: " + ClientBehaviour.player_id);
switch (clientMessageType)
{
case ClientMessage.Pong:
case ClientMessage.PlayerReady:
default:
break;
case ClientMessage.MovementInput:
WriteVector2(ref writer, sender.MovementInput);
break;
//case ClientMessage.ShootInput:
// writer.WriteByte(Convert.ToByte(sender.IsShooting));
// break;
case ClientMessage.PlayerID:
writer.WriteInt(ClientBehaviour.player_id);
break;
}
sender.m_Driver.EndSend(writer);
//AdditionalData.Dispose()
}
public void Serialize(ref DataStreamWriter writer)
{
new Message(id, MessageType.Welcome).Serialize(ref writer);
writer.WriteInt(playerID);
writer.WriteUInt(color.ToUInt());
}
public override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteInt(PlayerID);
writer.WriteUShort(newHP);
}
public override DataStreamWriter WritePacket(DataStreamWriter writer)
{
writer.WriteInt(ID);
for (int i = 0; i < P0WorldStateVariables.Items.Count; i++)
{
writer.WriteInt(P0WorldStateVariables.Items[i].Value);
}
for (int i = 0; i < P1WorldStateVariables.Items.Count; i++)
{
writer.WriteInt(P1WorldStateVariables.Items[i].Value);
}
for (int i = 0; i < OtherWorldStateVariables.Items.Count; i++)
{
writer.WriteInt(OtherWorldStateVariables.Items[i].Value);
}
return(writer);
}
public void SerializeRPC(ref DataStreamWriter writer, string methodName, params object[] args)
{
int index = _methodNameToIndex[methodName];
writer.WriteInt(index);
Type[] argumentTypes = _argumentTypes[index];
writer.WriteObjects(args, argumentTypes);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte(fillType ? (byte)1 : (byte)0);
writer.WriteFloat(centerX);
writer.WriteFloat(centerY);
writer.WriteFloat(radius);
writer.WriteInt((int)shape);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteInt(pilotSettings.Length);
for (int i = 0; i < pilotSettings.Length; i++)
{
writer.WriteFloat(pilotSettings[i]);
}
}
public override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteByte(NumberOfScores);
for (int i = 0; i < NumberOfScores; i++)
{
writer.WriteInt(PlayerID[i]);
writer.WriteUShort(HighScores[i]);
}
}
protected override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteFloat(Position.x);
writer.WriteFloat(Position.y);
writer.WriteFloat(Position.z);
writer.WriteInt(TierIndex);
}
public static void WriteVector3ListToStream(List <Vector3> vector3s, ref DataStreamWriter writer)
{
writer.WriteInt(vector3s.Count);
foreach (Vector3 vector3 in vector3s)
{
writer.WriteFloat(vector3.x);
writer.WriteFloat(vector3.y);
writer.WriteFloat(vector3.z);
}
}
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 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 override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteByte(NumberOfScores);
foreach (ScoreData scoreData in scoreData)
{
writer.WriteInt(scoreData.playerID);
writer.WriteUShort(scoreData.gold);
}
}
public override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteByte(NumberOfScores);
for (int i = 0; i < NumberOfScores; i++)
{
writer.WriteInt(PlayerScorePair.ElementAt(i).Key);
writer.WriteUShort(PlayerScorePair.ElementAt(i).Value);
}
}