public void CopyFromOtherWriterUnAlignedBig()
{
var value1 = (ulong)UnityEngine.Random.Range(0, 20000);
var value2 = (ulong)UnityEngine.Random.Range(0, 20000);
var value3 = (ulong)UnityEngine.Random.Range(0, 20000);
var value4 = (ulong)UnityEngine.Random.Range(0, 20000);
var value5 = (ulong)UnityEngine.Random.Range(0, 20000);
otherWriter.Write(value1, 46);
otherWriter.Write(value2, 47);
otherWriter.Write(value3, 48);
otherWriter.Write(value4, 49);
otherWriter.Write(value5, 50);
writer.WriteUInt64(5);
writer.Write(1, 3);
writer.WriteByte(171);
writer.CopyFromWriter(otherWriter, 0, 240);
var segment = writer.ToArraySegment();
reader.Reset(segment);
Assert.That(reader.ReadUInt64(), Is.EqualTo(5ul));
Assert.That(reader.Read(3), Is.EqualTo(1));
Assert.That(reader.ReadByte(), Is.EqualTo(171));
Assert.That(reader.Read(46), Is.EqualTo(value1), "Random value 1 not correct");
Assert.That(reader.Read(47), Is.EqualTo(value2), "Random value 2 not correct");
Assert.That(reader.Read(48), Is.EqualTo(value3), "Random value 3 not correct");
Assert.That(reader.Read(49), Is.EqualTo(value4), "Random value 4 not correct");
Assert.That(reader.Read(50), Is.EqualTo(value5), "Random value 5 not correct");
}
public static void Serialize(this NetworkWriter writer, UpdateTileMessage.NetMessage message)
{
writer.WriteUInt(message.MatrixSyncNetID);
foreach (var delayedData in message.Changes)
{
writer.WriteBool(true);
writer.WriteVector3Int(delayedData.Position);
writer.WriteInt((int)delayedData.TileType);
writer.WriteInt((int)delayedData.layerType);
writer.WriteString(delayedData.TileName);
if (delayedData.Colour != Color.white)
{
writer.WriteByte((byte)EnumOperation.Colour);
writer.WriteColor(delayedData.Colour);
}
if (delayedData.TransformMatrix != Matrix4x4.identity)
{
writer.WriteByte((byte)EnumOperation.Matrix4x4);
writer.WriteMatrix4x4(delayedData.TransformMatrix);
}
writer.WriteByte((byte)EnumOperation.NoMoreData);
}
writer.WriteBool(false);
}
public override void Serialize(NetworkWriter writer)
{
base.Serialize(writer);
// indicate unknown component if client requested it
if (ComponentType == null)
{
writer.WriteUInt16(UNKNOWN_COMPONENT_TYPE_ID);
}
else
{
writer.WriteUInt16(componentTypeToComponentID[ComponentType]);
}
writer.WriteByte(interactionTypeToInteractionID[InteractionType]);
//server determines processor object if client specified unknown component
if (ComponentType != null)
{
writer.WriteUInt32(ProcessorObject);
}
writer.WriteByte((byte)Intent);
if (InteractionType == typeof(PositionalHandApply))
{
writer.WriteUInt32(TargetObject);
writer.WriteVector2(TargetVector);
writer.WriteInt32((int)TargetBodyPart);
}
else if (InteractionType == typeof(HandApply))
{
writer.WriteUInt32(TargetObject);
writer.WriteInt32((int)TargetBodyPart);
writer.WriteBoolean(IsAltUsed);
}
else if (InteractionType == typeof(AimApply))
{
writer.WriteVector2(TargetVector);
writer.WriteBoolean(MouseButtonState == MouseButtonState.PRESS);
}
else if (InteractionType == typeof(MouseDrop))
{
writer.WriteUInt32(TargetObject);
writer.WriteUInt32(UsedObject);
}
else if (InteractionType == typeof(InventoryApply))
{
writer.WriteUInt32(UsedObject);
writer.WriteUInt32(Storage);
writer.WriteInt32(SlotIndex);
writer.WriteInt32((int)NamedSlot);
writer.WriteBoolean(IsAltUsed);
}
else if (InteractionType == typeof(TileApply))
{
writer.WriteVector2(TargetVector);
}
else if (InteractionType == typeof(TileMouseDrop))
{
writer.WriteUInt32(UsedObject);
writer.WriteVector2(TargetVector);
}
}
public void TestWriteMisaligned()
{
var outNetworkBuffer = new NetworkBuffer();
var outNetworkWriter = new NetworkWriter(outNetworkBuffer);
outNetworkWriter.WriteBit(true);
outNetworkWriter.WriteBit(false);
// now the stream is misalligned, lets write some bytes
outNetworkWriter.WriteByte(244);
outNetworkWriter.WriteByte(123);
outNetworkWriter.WriteInt16(-5457);
outNetworkWriter.WriteUInt64(4773753249);
outNetworkWriter.WriteUInt64Packed(5435285812313212);
outNetworkWriter.WriteInt64Packed(-5435285812313212);
outNetworkWriter.WriteBit(true);
outNetworkWriter.WriteByte(1);
outNetworkWriter.WriteByte(0);
var outBuffer = outNetworkBuffer.GetBuffer();
var inNetworkBuffer = new NetworkBuffer(outBuffer);
var inNetworkReader = new NetworkReader(inNetworkBuffer);
Assert.That(inNetworkReader.ReadBit(), Is.True);
Assert.That(inNetworkReader.ReadBit(), Is.False);
Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(244));
Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(123));
Assert.That(inNetworkReader.ReadInt16(), Is.EqualTo(-5457));
Assert.That(inNetworkReader.ReadUInt64(), Is.EqualTo(4773753249));
Assert.That(inNetworkReader.ReadUInt64Packed(), Is.EqualTo(5435285812313212));
Assert.That(inNetworkReader.ReadInt64Packed(), Is.EqualTo(-5435285812313212));
Assert.That(inNetworkReader.ReadBit(), Is.True);
Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(1));
Assert.That(inNetworkReader.ReadByte(), Is.EqualTo(0));
}
/// <summary>
/// Writes TransformSyncData into a writer.
/// </summary>
/// <param name="writer"></param>
/// <param name="syncData"></param>
public static void WriteTransformSyncData(this NetworkWriter writer, TransformSyncData syncData)
{
//SyncProperties.
SyncProperties sp = (SyncProperties)syncData.SyncProperties;
writer.WriteByte(syncData.SyncProperties);
//NetworkIdentity.
//Get compression level for netIdentity.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Id1))
{
writer.WriteByte((byte)syncData.NetworkIdentity);
}
else if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Id2))
{
writer.WriteUInt16((ushort)syncData.NetworkIdentity);
}
else
{
writer.WriteUInt32(syncData.NetworkIdentity);
}
//ComponentIndex.
writer.WriteByte(syncData.ComponentIndex);
//Position.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Position))
{
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.CompressSmall))
{
WriteCompressedVector3(writer, syncData.Position);
}
else
{
writer.WriteVector3(syncData.Position);
}
}
//Rotation.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Rotation))
{
writer.WriteUInt32(Quaternions.CompressQuaternion(syncData.Rotation));
}
//Scale.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Scale))
{
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.CompressSmall))
{
WriteCompressedVector3(writer, syncData.Scale);
}
else
{
writer.WriteVector3(syncData.Scale);
}
}
//Platform.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Platform))
{
writer.WriteUInt32(syncData.PlatformNetId);
}
}
public void Serialize(ref byte value)
{
if (IsReading)
{
value = m_Reader.ReadByteDirect();
}
else
{
m_Writer.WriteByte(value);
}
}
public override void Serialize(NetworkWriter writer)
{
base.Serialize(writer);
writer.WriteUInt16(componentTypeToComponentID[ComponentType]);
writer.WriteByte(interactionTypeToInteractionID[InteractionType]);
writer.WriteUInt32(ProcessorObject);
writer.WriteByte((byte)Intent);
if (InteractionType == typeof(PositionalHandApply))
{
writer.WriteUInt32(TargetObject);
writer.WriteVector2(TargetVector);
writer.WriteInt32((int)TargetBodyPart);
}
else if (InteractionType == typeof(HandApply))
{
writer.WriteUInt32(TargetObject);
writer.WriteInt32((int)TargetBodyPart);
writer.WriteBoolean(IsAltUsed);
}
else if (InteractionType == typeof(AimApply))
{
writer.WriteVector2(TargetVector);
writer.WriteBoolean(MouseButtonState == MouseButtonState.PRESS);
}
else if (InteractionType == typeof(MouseDrop))
{
writer.WriteUInt32(TargetObject);
writer.WriteUInt32(UsedObject);
}
else if (InteractionType == typeof(InventoryApply))
{
writer.WriteUInt32(UsedObject);
writer.WriteUInt32(Storage);
writer.WriteInt32(SlotIndex);
writer.WriteInt32((int)NamedSlot);
writer.WriteBoolean(IsAltUsed);
}
else if (InteractionType == typeof(TileApply))
{
writer.WriteVector2(TargetVector);
writer.WriteByte((byte)TileInteractionIndex);
}
else if (InteractionType == typeof(TileMouseDrop))
{
writer.WriteUInt32(UsedObject);
writer.WriteVector2(TargetVector);
writer.WriteByte((byte)TileInteractionIndex);
}
}
public void TestToArray()
{
// write 2 bytes
writer.WriteByte(1);
writer.WriteByte(2);
// .ToArray() length is 2?
Assert.That(writer.ToArray().Length, Is.EqualTo(2));
// set position back by one
writer.Position = 1;
// Changing the position should not alter the size of the data
Assert.That(writer.ToArray().Length, Is.EqualTo(2));
}
public void Serialize(ref NetworkWriter writer, IEntityReferenceSerializer refSerializer)
{
writer.WriteString("objectiveName", objectiveName);
writer.WriteByte("status", (byte)status);
writer.WriteFloatQ("captured", captured, 2);
}
public void OnSerializeDelta(NetworkWriter writer)
{
// write all the queued up changes
writer.WritePackedUInt32((uint)_changes.Count);
for (var i = 0; i < _changes.Count; i++)
{
var change = _changes[i];
writer.WriteByte((byte)change.Operation);
switch (change.Operation)
{
case Operation.OP_ADD:
writer.Write(change.Item);
break;
case Operation.OP_CLEAR:
break;
case Operation.OP_REMOVEAT:
writer.WritePackedUInt32((uint)change.Index);
break;
case Operation.OP_INSERT:
case Operation.OP_SET:
writer.WritePackedUInt32((uint)change.Index);
writer.Write(change.Item);
break;
}
}
}
public static void WritePickable(this NetworkWriter writer, Pickable pickable)
{
// This code will not work, if the pickable can be modified at runtime. Consider
// adding a bool flag to check if the pickable can be edited at runtime and then
// transmit all modified values.
if (pickable == null)
{
writer.WriteByte(0);
writer.WriteUInt16(0);
}
else
{
writer.WriteByte((byte)pickable.PickableType);
writer.WriteUInt16(pickable.Id);
}
}
public void OnSerializeDelta(NetworkWriter writer)
{
// write all the queued up changes
writer.WritePackedUInt32((uint)changes.Count);
for (int i = 0; i < changes.Count; i++)
{
Change change = changes[i];
writer.WriteByte((byte)change.operation);
switch (change.operation)
{
case Operation.OP_ADD:
writer.Write(change.item);
break;
case Operation.OP_CLEAR:
break;
case Operation.OP_REMOVE:
writer.Write(change.item);
break;
}
}
}
/// <summary>
/// Writes TransformSyncData into a writer.
/// </summary>
/// <param name="writer"></param>
/// <param name="syncData"></param>
public static void WriteTransformSyncData(this NetworkWriter writer, TransformSyncData syncData)
{
//SyncProperties.
SyncProperties sp = (SyncProperties)syncData.SyncProperties;
writer.WriteByte(syncData.SyncProperties);
//SequenceId.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Sequenced))
{
writer.WriteUInt32(syncData.SequenceId);
}
//Position.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Position))
{
writer.WriteVector3(syncData.Position);
}
//Rotation.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Rotation))
{
WriteCompressedQuaternion(writer, syncData.Rotation);
}
//Scale.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Scale))
{
writer.WriteVector3(syncData.Scale);
}
//Platform.
if (EnumContains.SyncPropertiesContains(sp, SyncProperties.Platform))
{
writer.WriteUInt32(syncData.PlatformNetId);
}
}
public void Serialize(ref NetworkWriter writer, IEntityReferenceSerializer refSerializer)
{
writer.WriteInt32("tick", checkTick);
writer.WriteInt32("renderTick", renderTick);
writer.WriteFloatQ("moveYaw", moveYaw, 0);
writer.WriteFloatQ("moveMagnitude", moveMagnitude, 2);
writer.WriteFloat("lookYaw", lookYaw);
writer.WriteFloat("lookPitch", lookPitch);
writer.WriteBoolean("jump", jump);
writer.WriteBoolean("boost", boost);
writer.WriteBoolean("sprint", sprint);
writer.WriteBoolean("primaryFire", primaryFire);
writer.WriteBoolean("secondaryFire", secondaryFire);
writer.WriteBoolean("abilityA", abilityA);
writer.WriteBoolean("reload", reload);
writer.WriteBoolean("melee", melee);
writer.WriteBoolean("use", use);
writer.WriteByte("emote", (byte)emote);
//VR controls
writer.WriteVector3Q("rightControllerPos", rightControllerPos, 2);
writer.WriteVector3Q("leftControllerPos", leftControllerPos, 2);
writer.WriteVector3Q("headsetPos", headsetPos, 2);
writer.WriteQuaternion("rightControllerRot", rightControllerRot);
writer.WriteQuaternion("leftControllerRot", leftControllerRot);
writer.WriteQuaternion("headsetRot", headsetRot);
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
if (initialState)
{
writer.WriteByte(_owner.Id);
writer.WriteByte(_unit.CategoryId);
writer.WriteInt32(_unit.Id);
writer.WriteSingle(FinalHeading);
}
else
{
writer.WriteSingle(FinalHeading);
writer.WriteByte((byte)_units.Count);
}
return(true);
}
public override void Serialize(NetworkWriter _writer)
{
base.Serialize(_writer);
_writer.WriteInt32(callbackId);
_writer.WriteByte((byte)status);
_writer.WriteString(MsgType.FullName);
message.Serialize(_writer);
}
public static void WriteWorldObjectData(this NetworkWriter writer, WorldObjectData data)
{
writer.WriteInt32((int)data.ObjectType);
writer.WriteUInt32(data.Key);
writer.WriteBoolean(data.Instantiated);
//Ïsland type.
if (data is IslandObjectData od)
{
writer.WriteByte((byte)od.TreeState);
}
//Tree type.
if (data is TreeObjectData op)
{
writer.WriteByte((byte)op.TreeState);
}
}
public static void WriteServerConfig(this NetworkWriter writer, ServerConfig config)
{
writer.WriteString(config.gameName);
writer.WriteByte((byte)config.motdMode);
if (config.motdMode == Server.ServerMOTDMode.TextOnly)
{
writer.WriteString(config.motdText);
}
}
public void MakeNextBatch_OnlyAcceptsFreshWriter()
{
batcher.AddMessage(new ArraySegment <byte>(new byte[] { 0x01 }));
writer.WriteByte(0);
Assert.Throws <ArgumentException>(() => {
batcher.MakeNextBatch(writer);
});
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
var behaviour = context.entityManager.GetComponentObject <CapturePoint>(context.entity);
writer.WriteString("objectiveName", behaviour.objectiveName);
writer.WriteByte("status", (byte)behaviour.status);
writer.WriteFloatQ("captured", behaviour.captured, 2);
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
bool canSend = false;
if (initialState)
{
writer.WriteByte(Owner.Id);
writer.WriteByte(Unit.CategoryId);
writer.WriteInt32(Unit.Id);
canSend = true;
}
else
{
// TODO
}
return(canSend);
}
/// <summary>
/// Writes a compressed Vector3 to the writer.
/// </summary>
/// <param name="writer"></param>
/// <param name="ca"></param>
/// <param name="v"></param>
private static void WriteCompressedVector3(NetworkWriter writer, Vector3 v)
{
CompressedAxes ca = CompressedAxes.None;
//If can compress X.
float absX = Mathf.Abs(v.x);
if (absX <= MAX_COMPRESSION_VALUE)
{
ca |= (Mathf.Sign(v.x) > 0f) ? CompressedAxes.XPositive : CompressedAxes.XNegative;
}
//If can compress Y.
float absY = Mathf.Abs(v.y);
if (absY <= MAX_COMPRESSION_VALUE)
{
ca |= (Mathf.Sign(v.y) > 0f) ? CompressedAxes.YPositive : CompressedAxes.YNegative;
}
//If can compress Z.
float absZ = Mathf.Abs(v.z);
if (absZ <= MAX_COMPRESSION_VALUE)
{
ca |= (Mathf.Sign(v.z) > 0f) ? CompressedAxes.ZPositive : CompressedAxes.ZNegative;
}
//Write compresed axes.
writer.WriteByte((byte)ca);
//X
if (EnumContains.CompressedAxesContains(ca, CompressedAxes.XNegative) || EnumContains.CompressedAxesContains(ca, CompressedAxes.XPositive))
{
writer.WriteUInt16((ushort)Mathf.Round(absX * 100f));
}
else
{
writer.WriteSingle(v.x);
}
//Y
if (EnumContains.CompressedAxesContains(ca, CompressedAxes.YNegative) || EnumContains.CompressedAxesContains(ca, CompressedAxes.YPositive))
{
writer.WriteUInt16((ushort)Mathf.Round(absY * 100f));
}
else
{
writer.WriteSingle(v.y);
}
//Z
if (EnumContains.CompressedAxesContains(ca, CompressedAxes.ZNegative) || EnumContains.CompressedAxesContains(ca, CompressedAxes.ZPositive))
{
writer.WriteUInt16((ushort)Mathf.Round(absZ * 100f));
}
else
{
writer.WriteSingle(v.z);
}
}
public static void WriteAnimatorUpdate(this NetworkWriter writer, AnimatorUpdate au)
{
//Component index.
writer.WriteByte(au.ComponentIndex);
//Write compressed network identity.
//byte.
if (au.NetworkIdentity <= byte.MaxValue)
{
writer.WriteByte(1);
writer.WriteByte((byte)au.NetworkIdentity);
}
//ushort.
else if (au.NetworkIdentity <= ushort.MaxValue)
{
writer.WriteByte(2);
writer.WriteUInt16((ushort)au.NetworkIdentity);
}
//Full value.
else
{
writer.WriteByte(4);
writer.WriteUInt32(au.NetworkIdentity);
}
//Animation data.
//Compress data length.
if (au.Data.Length <= byte.MaxValue)
{
writer.WriteByte(1);
writer.WriteByte((byte)au.Data.Length);
}
else if (au.Data.Length <= ushort.MaxValue)
{
writer.WriteByte(2);
writer.WriteUInt16((ushort)au.Data.Length);
}
else
{
writer.WriteByte(4);
writer.WriteInt32(au.Data.Length);
}
if (au.Data.Length > 0)
{
writer.WriteBytes(au.Data, 0, au.Data.Length);
}
}
public void Serialize(ref SerializeContext context, ref NetworkWriter networkWriter)
{
networkWriter.WriteInt32("tick", checkTick);
networkWriter.WriteInt32("renderTick", renderTick);
networkWriter.WriteFloatQ("moveYaw", moveYaw, 0);
networkWriter.WriteFloatQ("moveMagnitude", moveMagnitude, 2);
networkWriter.WriteFloat("lookYaw", lookYaw);
networkWriter.WriteFloat("lookPitch", lookPitch);
networkWriter.WriteUInt32("buttons", buttons.flags);
networkWriter.WriteByte("emote", (byte)emote);
}
// Make custom writer(private)
private static void MakeCustomSyncWriter(NetworkIdentity behaviorOwner, Type targetType, Action <NetworkWriter> customSyncObject, Action <NetworkWriter> customSyncVar, NetworkWriter owner, NetworkWriter observer)
{
byte behaviorDirty = 0;
NetworkBehaviour behaviour = null;
// Get NetworkBehaviors index (behaviorDirty use index)
for (int i = 0; i < behaviorOwner.NetworkBehaviours.Length; i++)
{
if (behaviorOwner.NetworkBehaviours[i].GetType() == targetType)
{
behaviour = behaviorOwner.NetworkBehaviours[i];
behaviorDirty = (byte)i;
break;
}
}
// Write target NetworkBehavior's dirty
owner.WriteByte(behaviorDirty);
// Write init position
int position = owner.Position;
owner.WriteInt32(0);
int position2 = owner.Position;
// Write custom sync data
if (customSyncObject != null)
{
customSyncObject.Invoke(owner);
}
else
{
behaviour.SerializeObjectsDelta(owner);
}
// Write custom syncvar
customSyncVar?.Invoke(owner);
// Write syncdata position data
int position3 = owner.Position;
owner.Position = position;
owner.WriteInt32(position3 - position2);
owner.Position = position3;
// Copy owner to observer
if (behaviour.syncMode != SyncMode.Observers)
{
ArraySegment <byte> arraySegment = owner.ToArraySegment();
observer.WriteBytes(arraySegment.Array, position, owner.Position - position);
}
}
public static void WriteItem(this NetworkWriter writer, Skill skill)
{
if (skill is BasicAttack basicAttack)
{
writer.WriteByte(BASICATTACK);
writer.WriteInt32(basicAttack.damage);
}
else if (skill is BasicHeal basicHeal)
{
writer.WriteByte(BASICHEAL);
writer.WriteInt32(basicHeal.heal);
}
else if (skill is Fireball fireball)
{
writer.WriteByte(BASICFIREBALL);
writer.Write <Effect>(fireball.effect);
writer.WriteInt32(fireball.fireDamage);
writer.WriteInt32(fireball.damage);
}
writer.WriteString(skill.name);
writer.WriteString(skill.description);
}
/// <summary>
/// Writes a compressed quaternion to a writer.
/// </summary>
/// <param name="writer"></param>
/// <param name="rotation"></param>
public static void WriteCompressedQuaternion(NetworkWriter writer, Quaternion rotation)
{
byte largest;
short a, b, c;
Quaternions.CompressQuaternion(rotation, out largest, out a, out b, out c);
writer.WriteByte(largest);
if (!Quaternions.UseLargestOnly(largest))
{
writer.WriteInt16(a);
writer.WriteInt16(b);
writer.WriteInt16(c);
}
}
public override bool OnSerialize(NetworkWriter writer, bool initialState)
{
bool dataWritten = base.OnSerialize(writer, initialState);
if (initialState)
{
writer.WriteByte((byte)this.levelPhase.CurrentState);
dataWritten = true;
}
dataWritten |= ((LevelPhaseState)this.levelPhase.CurrentStateObject).OnSerialize(writer, initialState);
return(dataWritten);
}
public void Serialize(ref SerializeContext context, ref NetworkWriter writer)
{
writer.WriteInt32("tick", tick);
writer.WriteVector3Q("velocity", velocity, 2);
writer.WriteInt32("action", (int)action);
writer.WriteInt32("actionStartTick", actionStartTick);
writer.WriteInt32("phase", (int)locoState);
writer.WriteInt32("phaseStartTick", locoStartTick);
writer.WriteVector3Q("position", position, 2);
writer.WriteInt32("jumpCount", jumpCount);
writer.WriteBoolean("sprint", sprinting == 1);
writer.WriteByte("cameraProfile", (byte)cameraProfile);
writer.WriteInt32("damageTick", damageTick);
writer.WriteVector3Q("damageDirection", damageDirection);
}
public void DeserializeDeltaReadsNetIdAndComponentIndex()
{
NetworkWriter writer = new NetworkWriter();
writer.WriteUInt(serverComponent.netId);
writer.WriteByte((byte)serverComponent.ComponentIndex);
NetworkReader reader = new NetworkReader(writer.ToArraySegment());
SyncVarNetworkBehaviour <EmptyBehaviour> field = new SyncVarNetworkBehaviour <EmptyBehaviour>(null);
// avoid 'not initialized' exception
field.OnDirty = () => {};
field.OnDeserializeDelta(reader);
Assert.That(field.Value, Is.EqualTo(serverComponent));
}