public void Write(NetArchive archive, ISerializableObjectReferenceCollector collector, params object[] args) {
if (args.Length != argumentSerializers.Count) {
throw new ArgumentException("Wrong number of arguments for RPC!");
}
for (int i = 0; i < args.Length; ++i) {
object r = args[i];
argumentSerializers[i].Serialize(archive, collector, ref r, null);
}
}
public void Write(NetArchive archive, ISerializableObjectReferenceCollector collector, object fieldVal, bool deltaField) {
Perf.Begin("FieldState.Write");
fieldSpec.serializer.Serialize(archive, collector, ref fieldVal, deltaField ? lastState : null);
if (deltaField) {
lastState = fieldSpec.serializer.Copy(fieldVal);
}
Perf.End();
}
public object[] Read(NetArchive archive, ISerializableObjectReferenceCollector collector) {
for (int i = 0; i < argumentSerializers.Count; ++i) {
var p = _parameters[i];
if (p.ParameterType.IsValueType) {
rpcArgs[i] = Activator.CreateInstance(p.ParameterType);
} else {
rpcArgs[i] = null;
}
argumentSerializers[i].Serialize(archive, collector, ref rpcArgs[i], null);
}
return rpcArgs;
}
public ReplicatedObjectRPC()
{
stream = new System.IO.MemoryStream();
_archive = new NetArchive(stream, false, true);
}
bool SerializeFields(float dt, NetArchive archive, bool deltasOnly, bool netFlush) {
Perf.Begin("SerializeFields");
ActorReplicationChannel.CHECK_FLD(archive);
isLoading = archive.isLoading;
if (isLoading) {
byte numBits = archive.ReadByte();
Assert.IsTrue(numBits <= SerializedObjectFields.MAX_REPLICATED_FIELDS);
uint fieldBits = archive.ReadUnsignedBits(numBits);
ActorReplicationChannel.CHECK_FLD(archive);
for (int i = 0; i < numBits; ++i) {
if (((1U << i) & fieldBits) != 0) {
var fieldState = fieldStates.Values[i];
curFieldState = fieldState;
object obj = fieldState.fieldSpec.field.GetValue(_object);
object orig = obj;
ActorReplicationChannel.CHECK_FLD(archive);
if (fieldState.fieldSpec.serializer.Serialize(archive, this, ref obj, null)) {
fieldState.needsRep = fieldState.fieldSpec.onRep != null;
if (fieldState.needsRep) {
++numOnReps;
}
}
ActorReplicationChannel.CHECK_FLD(archive);
if (obj != orig) {
fieldState.fieldSpec.field.SetValue(_object, obj);
}
}
}
curFieldState = null;
Perf.End();
return numBits > 0;
} else {
fieldsToReplicate.Clear();
byte numBitsWritten = 0;
uint fieldBits = 0;
for (int i = 0; i < fieldStates.Values.Count; ++i) {
var field = fieldStates.Values[i];
object fieldVal;
bool deltaField;
if (field.IsDirty(channel, _object, dt, deltasOnly, hasReplicated, isOwner, netFlush, out fieldVal, out deltaField)) {
numBitsWritten = (byte)(i + 1);
fieldBits |= 1U << i;
fieldsToReplicate.Add(new FieldReplicateInfo(i, fieldVal, deltaField));
}
}
Assert.IsTrue(numBitsWritten <= SerializedObjectFields.MAX_REPLICATED_FIELDS);
archive.Write(numBitsWritten);
archive.WriteUnsignedBits(fieldBits, numBitsWritten);
ActorReplicationChannel.CHECK_FLD(archive);
for (int i = 0; i < fieldsToReplicate.Count; ++i) {
var info = fieldsToReplicate[i];
var field = fieldStates.Values[info.index];
ActorReplicationChannel.CHECK_FLD(archive);
field.Write(archive, this, info.fieldVal, info.deltaField);
ActorReplicationChannel.CHECK_FLD(archive);
}
fieldsToReplicate.Clear();
hasReplicated = true;
Perf.End();
return numBitsWritten > 0;
}
}
public bool DeltaSerialize(float dt, NetArchive archive, bool netFlush) {
var r = SerializeFields(serializeDeltaTime + dt, archive, true, netFlush);
serializeDeltaTime = 0f;
return r;
}
public bool FullSerialize(float dt, NetArchive archive) {
var r = SerializeFields(serializeDeltaTime + dt, archive, false, true);
serializeDeltaTime = 0f;
return r;
}
