public void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte(keyForwardPressed);
writer.WriteByte(keyBackwardPressed);
writer.WriteByte(keyTurnRightPressed);
writer.WriteByte(keyTurnLeftPressed);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte(left);
writer.WriteByte(right);
writer.WriteByte(thrust);
writer.WriteByte(shoot);
}
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 void Serialize(ref DataStreamWriter writer, ShipCommandData baseline, NetworkCompressionModel compressionModel)
{
writer.WriteByte(left);
writer.WriteByte(right);
writer.WriteByte(thrust);
writer.WriteByte(shoot);
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteFloat(this.horizMove);
writer.WriteFloat(this.vertMove);
writer.WriteFloat(this.targetPitch);
writer.WriteFloat(this.targetYaw);
writer.WriteByte(this.jump);
writer.WriteByte(this.interact);
writer.WriteByte(this.sprint);
}
public override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteByte(MoveDirections);
writer.WriteUShort(TreasureInRoom);
writer.WriteByte(ContainsMonster);
writer.WriteByte(ContainsExit);
writer.WriteByte(NumberOfOtherPlayers);
for (int i = 0; i < NumberOfOtherPlayers; i++)
{
writer.WriteInt(OtherPlayerIDs[i]);
}
}
public void Serialize(ref DataStreamWriter writer)
{
new Message(id, MessageType.RoomInfo).Serialize(ref writer);
writer.WriteByte((byte)moveDirections);
writer.WriteUShort(treasureInRoom);
writer.WriteByte(Convert.ToByte(containsMonster));
writer.WriteByte(Convert.ToByte(containsExit));
writer.WriteByte(numberOfOtherPlayers);
for (int i = 0; i < numberOfOtherPlayers; i++)
{
writer.WriteInt(otherPlayerIDs[i]);
}
}
public void WriteMessage(ref DataStreamWriter _writer, MessageBase msg)
{
byte[] _bytes = new byte[BYTE_ARRAY_SIZE];
//PACK THE DATA INTO BYTES
BinaryFormatter _formatter = new BinaryFormatter();
byte[] _tempBuffer;
using (var _stream = new MemoryStream())
{
_formatter.Serialize(_stream, msg);
_tempBuffer = _stream.ToArray();
}
//save the data
for (int i = 0; i < _tempBuffer.Length; i++)
{
_bytes[i] = _tempBuffer[i];
}
//WRITE IT TO THE DATA STREAM
for (int i = 0; i < BYTE_ARRAY_SIZE; i++)
{
_writer.WriteByte(_bytes[i]);
}
}
/// <summary>
/// 把输入写入发送buffer中
/// </summary>
/// <param name="buffer"></param>
/// <param name="data"></param>
/// <exception cref="InvalidOperationException"></exception>
public unsafe void Schedule(DynamicBuffer <OutgoingRpcDataStreamBufferComponent> buffer, TActionRequest data)
{
TActionSerializer serializer = default;
// 1字节:Rpc协议头 2字节:rpcIndex
DataStreamWriter writer =
new DataStreamWriter(UnsafeUtility.SizeOf <TActionRequest>() + 1 + 2, Allocator.Temp);
if (buffer.Length == 0)
{
writer.WriteByte((byte)NetworkStreamProtocol.Rpc);
}
if (!rpcTypeHashToIndex.TryGetValue(rpcType, out var rpcIndex))
{
throw new InvalidOperationException("Could not find RPC index for type");
}
writer.WriteUShort((ushort)rpcIndex);
serializer.Serialize(ref writer, data);
// 把DataStreamWriter内存数据Copy到Buffer中
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 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 override void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte((byte)Code);
writer.WriteInt(Entity.UID);
writer.WriteByte((byte)Entity.Type);
writer.WriteByte((byte)Entity.Dirty);
if (Entity.Dirty.HasFlag(EntityFlag.position))
{
SerializePosition(ref writer);
}
if (Entity.Dirty.HasFlag(EntityFlag.visual))
{
SerializeVisual(ref writer);
}
}
public void Serialize(ref DataStreamWriter writer, VoxelStencilInput baseline, NetworkCompressionModel compressionModel)
{
writer.WriteByte(fillType ? (byte)1 : (byte)0);
writer.WritePackedFloat(centerX, compressionModel);
writer.WritePackedFloat(centerY, compressionModel);
writer.WritePackedFloat(radius, compressionModel);
writer.WritePackedInt((int)shape, compressionModel);
}
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.WriteByte(Convert.ToByte(HasTarget));
if (HasTarget)
{
writer.WriteIntNetworkByteOrder(TargetPlayerId);
}
}
public void Serialize(ref DataStreamWriter writer, bool fullLoad)
{
if (fullLoad)
{
_dirtyMask = 255;
}
writer.WriteByte(_dirtyMask);
Serialize(ref writer, _dirtyMask);
_dirtyMask = 0;
}
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]);
}
}
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);
}
}
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 Serialize(ref DataStreamWriter writer)
{
new Message(id, MessageType.EndGame).Serialize(ref writer);
writer.WriteByte(numberOfScores);
for (int i = 0; i < numberOfScores; i++)
{
writer.WriteInt(highScores[i].Key);
writer.WriteUShort(highScores[i].Value);
}
}
public void Execute([ReadOnly] ref NetworkStreamConnection connection,
[ReadOnly] ref NetworkSnapshotAckComponent ack, [ReadOnly] ref CommandTargetComponent state)
{
if (isNullCommandData && state.targetEntity != Entity.Null)
{
return;
}
if (!isNullCommandData && !inputFromEntity.Exists(state.targetEntity))
{
return;
}
DataStreamWriter writer = driver.BeginSend(unreliablePipeline, connection.Value);
if (!writer.IsCreated)
{
return;
}
writer.WriteByte((byte)NetworkStreamProtocol.Command);
writer.WriteUInt(ack.LastReceivedSnapshotByLocal);
writer.WriteUInt(ack.ReceivedSnapshotByLocalMask);
writer.WriteUInt(localTime);
uint returnTime = ack.LastReceivedRemoteTime;
if (returnTime != 0)
{
returnTime -= (localTime - ack.LastReceiveTimestamp);
}
writer.WriteUInt(returnTime);
writer.WriteUInt(interpolationDelay);
writer.WriteUInt(inputTargetTick);
if (state.targetEntity != Entity.Null)
{
var input = inputFromEntity[state.targetEntity];
TCommandData baselineInputData;
input.GetDataAtTick(inputTargetTick, out baselineInputData);
baselineInputData.Serialize(ref writer);
for (uint inputIndex = 1; inputIndex < k_InputBufferSendSize; ++inputIndex)
{
TCommandData inputData;
input.GetDataAtTick(inputTargetTick - inputIndex, out inputData);
inputData.Serialize(ref writer, baselineInputData, compressionModel);
}
writer.Flush();
}
#if UNITY_EDITOR || DEVELOPMENT_BUILD
netStats[0] = inputTargetTick;
netStats[1] = (uint)writer.Length;
#endif
driver.EndSend(writer);
}
public unsafe void Schedule(DynamicBuffer <OutgoingRpcDataStreamBufferComponent> buffer,
ComponentDataFromEntity <GhostComponent> ghostFromEntity, TActionRequest data)
{
var serializer = default(TActionSerializer);
var serializerState = new RpcSerializerState {
GhostFromEntity = ghostFromEntity
};
var msgHeaderLen = dynamicAssemblyList ? 10 : 4;
int maxSize = UnsafeUtility.SizeOf <TActionRequest>() + msgHeaderLen + 1;
int rpcIndex = 0;
if (!dynamicAssemblyList && !rpcTypeHashToIndex.TryGetValue(rpcType, out rpcIndex))
{
throw new InvalidOperationException("Could not find RPC index for type");
}
while (true)
{
DataStreamWriter writer = new DataStreamWriter(maxSize, Allocator.Temp);
int packetHeaderLen = 0;
if (buffer.Length == 0)
{
packetHeaderLen = 1;
writer.WriteByte((byte)NetworkStreamProtocol.Rpc);
}
if (dynamicAssemblyList)
{
writer.WriteULong(rpcType);
}
else
{
writer.WriteUShort((ushort)rpcIndex);
}
var lenWriter = writer;
writer.WriteUShort((ushort)0);
serializer.Serialize(ref writer, serializerState, data);
if (!writer.HasFailedWrites)
{
if (writer.Length - packetHeaderLen > ushort.MaxValue)
{
throw new InvalidOperationException("RPC is too large to serialize");
}
lenWriter.WriteUShort((ushort)(writer.Length - msgHeaderLen - packetHeaderLen));
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);
break;
}
maxSize *= 2;
}
}
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 ReadingDataFromStreamWithSliceOffset()
{
var dataStream = new DataStreamWriter(100, Allocator.Temp);
dataStream.WriteByte((byte)'a');
dataStream.WriteByte((byte)'b');
dataStream.WriteByte((byte)'c');
dataStream.WriteByte((byte)'d');
dataStream.WriteByte((byte)'e');
dataStream.WriteByte((byte)'f');
var reader = new DataStreamReader(dataStream.AsNativeArray().GetSubArray(3, 3));
Assert.AreEqual('d', reader.ReadByte());
Assert.AreEqual('e', reader.ReadByte());
Assert.AreEqual('f', reader.ReadByte());
}
public void Serialize(ref DataStreamWriter writer)
{
writer.WriteUIntNetworkByteOrder(PowerupId);
writer.WriteByte(Convert.ToByte(Enabled));
}
public static void WriteNativeString32(this DataStreamWriter writer, NativeString32 str)
{
writer.WriteByte(str.buffer.byte0000);
writer.WriteByte(str.buffer.byte0001);
writer.WriteByte(str.buffer.byte0002);
writer.WriteByte(str.buffer.byte0003);
writer.WriteByte(str.buffer.byte0004);
writer.WriteByte(str.buffer.byte0005);
writer.WriteByte(str.buffer.byte0006);
writer.WriteByte(str.buffer.byte0007);
writer.WriteByte(str.buffer.byte0008);
writer.WriteByte(str.buffer.byte0009);
writer.WriteByte(str.buffer.byte0010);
writer.WriteByte(str.buffer.byte0011);
writer.WriteByte(str.buffer.byte0012);
writer.WriteByte(str.buffer.byte0013);
writer.WriteByte(str.buffer.byte0014.byte0000);
writer.WriteByte(str.buffer.byte0014.byte0001);
writer.WriteByte(str.buffer.byte0014.byte0002);
writer.WriteByte(str.buffer.byte0014.byte0003);
writer.WriteByte(str.buffer.byte0014.byte0004);
writer.WriteByte(str.buffer.byte0014.byte0005);
writer.WriteByte(str.buffer.byte0014.byte0006);
writer.WriteByte(str.buffer.byte0014.byte0007);
writer.WriteByte(str.buffer.byte0014.byte0008);
writer.WriteByte(str.buffer.byte0014.byte0009);
writer.WriteByte(str.buffer.byte0014.byte0010);
writer.WriteByte(str.buffer.byte0014.byte0011);
writer.WriteByte(str.buffer.byte0014.byte0012);
writer.WriteByte(str.buffer.byte0014.byte0013);
writer.WriteByte(str.buffer.byte0014.byte0014);
writer.WriteByte(str.buffer.byte0014.byte0015);
}
public override void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte((byte)Code);
writer.WriteFixedString512(MessageContent); // fixe byte lenght
}
public override void Serialize(ref DataStreamWriter writer)
{
writer.WriteByte((byte)Code);
writer.WriteInt(UID);
}
public void Serialize(ref DataStreamWriter writer)
{
new Message(id, MessageType.MoveRequest).Serialize(ref writer);
writer.WriteByte((byte)direction);
}
public override void SerializeObject(ref DataStreamWriter writer)
{
base.SerializeObject(ref writer);
writer.WriteByte((byte)MoveDirection);
}