public SnapshotReplicator(INetworkObjectSerializerManager manager, string version)
{
var serializer = new SnapshotSerializer(manager, version);
_recvChannel = new SnapshotRecvChannel(serializer);
_sendChannel = new SnapshotSendChannel(serializer);
}
public override void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager manager)
{
int entityId = reader.ReadInt32();
short entityType = reader.ReadInt16();
Key = new EntityKey(entityId, entityType);
}
public override void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager)
{
var componentTypeId = Component.GetComponentId();
INetworkObjectSerializer componentSerializer = serializerManager.GetSerializer(componentTypeId);
componentSerializer.Merge(Component as INetworkObject, target, _bitMask);
}
public void ApplyPatchTo(ISnapshot baseSnap, INetworkObjectSerializerManager serializerManager)
{
foreach (var patch in _entityPatchList)
{
patch.ApplyPatchTo(baseSnap, serializerManager);
}
}
public override void ApplyPatchTo(ISnapshot snap, INetworkObjectSerializerManager serializerManager)
{
IGameEntity entity = snap.GetOrCreate(Key);
for (int i = 0; i < ComponentPatchList.Count; i++)
{
ComponentPatchList[i].ApplyPatchTo(entity, serializerManager);
}
}
public override void ApplyPatchTo(ISnapshot snap, INetworkObjectSerializerManager serializerManager)
{
var baseEntity = snap.GetEntity(Key);
foreach (var compPatch in ComponentPatchList)
{
compPatch.ApplyPatchTo(baseEntity, serializerManager);
}
}
public void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write(BaseSnapshotSeq);
writer.Write(_entityPatchList.Count);
foreach (var item in _entityPatchList)
{
item.Serialize(writer, serializerManager);
}
}
public override void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager serializerManager)
{
var typeId = reader.ReadInt16();
CreateGameComponent(typeId);
var componentSerializer = serializerManager.GetSerializer(typeId);
componentSerializer.DeserializeAll(Component as INetworkObject, DoCompress, reader);
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write((byte)ComponentReplicateOperationType.Add);
var componentId = Component.GetComponentId();
writer.Write((short)componentId);
var componentSerializer = serializerManager.GetSerializer(componentId);
componentSerializer.SerializeAll(Component as INetworkObject, DoCompress, writer);
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write((byte)EntityReplicateOperationType.Mod);
writer.Write(Key.EntityId);
writer.Write(Key.EntityType);
writer.Write((short)ComponentPatchList.Count);
for (int i = 0; i < ComponentPatchList.Count; i++)
{
ComponentPatchList[i].Serialize(writer, serializerManager);
}
}
public override void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager serializerManager)
{
int typeId = reader.ReadInt16();
CreateGameComponent(typeId);
var componentSerializer = serializerManager.GetSerializer(typeId);
_bitMask.Deserialize(reader);
var networkObject = Component as INetworkObject;
componentSerializer.Deserialize(networkObject, _bitMask, DoCompress, reader);
}
public void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager serializerManager)
{
BaseSnapshotSeq = reader.ReadInt32();
AssertUtility.Assert(_entityPatchList.Count == 0);
var count = reader.ReadInt32();
for (int i = 0; i < count; i++)
{
AbstractEntityPatch patch = CreateEntityPatch((EntityReplicateOperationType)reader.ReadByte());
patch.DeSerialize(reader, serializerManager);
_entityPatchList.Add(patch);
}
}
public override void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager serializerManager)
{
var id = reader.ReadInt32();
var type = reader.ReadInt16();
Key = new EntityKey(id, type);
int count = reader.ReadInt32();
AssertUtility.Assert(ComponentPatchList.Count == 0);
for (int i = 0; i < count; i++)
{
reader.ReadByte(); // var op
var patch = CreateEmptyComponentPatch();
patch.DeSerialize(reader, serializerManager);
ComponentPatchList.Add(patch);
}
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
var start = writer.BaseStream.Length;
writer.Write((byte)ComponentReplicateOperationType.Mod);
var componentId = Component.GetComponentId();
AssertUtility.Assert(componentId < 65535);
writer.Write((short)componentId);
_bitMask.Serialize(writer);
var componentSerializer = serializerManager.GetSerializer(componentId);
componentSerializer.Serialize(LastComponent as INetworkObject, Component as INetworkObject, _bitMask, DoCompress, writer);
var end = writer.BaseStream.Length;
var length = end - start;
_total[componentId] += length;
_current[componentId] = length;
_count[componentId] += 1;
_average[componentId] = _total[componentId] / _count[componentId];
}
public override void ApplyPatchTo(IGameEntity entity, INetworkObjectSerializerManager serializerManager)
{
entity.RemoveComponent(Component.GetComponentId());
}
public abstract void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager);
public abstract void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager manager);
public abstract void ApplyPatchTo(IGameEntity entity, INetworkObjectSerializerManager serializerManager);
public abstract void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager manager);
public override void DeSerialize(BinaryReader reader, INetworkObjectSerializerManager serializerManager)
{
int typeId = reader.ReadInt16();
CreateGameComponent(typeId);
}
public override void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager)
{
throw new System.NotImplementedException();
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager manager)
{
writer.Write((byte)EntityReplicateOperationType.Del);
writer.Write(Key.EntityId);
writer.Write(Key.EntityType);
}
public override void ApplyPatchTo(IGameEntity entity, INetworkObjectSerializerManager serializerManager)
{
var copyCopy = entity.AddComponent(Component.GetComponentId(), Component);
}
public override void ApplyPatchTo(INetworkObject target, INetworkObjectSerializerManager serializerManager)
{
target.CopyFrom(Component);
}
public override void Serialize(MyBinaryWriter writer, INetworkObjectSerializerManager serializerManager)
{
writer.Write((byte)ComponentReplicateOperationType.Del);
writer.Write((short)Component.GetComponentId());
}
public SnapshotPatchGenerator(INetworkObjectSerializerManager serializerManager)
{
snapshotPatch = SnapshotPatch.Allocate();
this.serializerManager = serializerManager;
}
public override void ApplyPatchTo(ISnapshot snap, INetworkObjectSerializerManager serializerManager)
{
snap.RemoveEntity(Key);
}
public abstract void ApplyPatchTo(ISnapshot snap, INetworkObjectSerializerManager serializerManager);
public SnapshotSerializer(INetworkObjectSerializerManager manager, string version)
{
_serializerManager = manager;
_version = version;
}
public SnapshotSerializer(INetworkObjectSerializerManager manager)
{
_serializerManager = manager;
}
