protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
int delta = reader.ReadInt32();
networkValue = fixRange(networkValue + delta);
setInterpolationTarget(fixRange(targetValue + delta));
}
protected override T readEventArg(BinaryReader reader, NetVersion version)
{
T arg = new T();
arg.Read(reader);
return(arg);
}
protected override T readEventArg(BinaryReader reader, NetVersion version)
{
TField val = new TField();
val.ReadFull(reader, version);
return(val.Value);
}
private void removed(TKey key, TField field, NetVersion reassign)
{
outgoingChanges.Add(new OutgoingChange(removal: true, key, field, reassign));
clearFieldParent(field);
MarkDirty();
removedEvent(key, field);
}
protected virtual TField ReadFieldFull(BinaryReader reader, NetVersion version)
{
TField val = new TField();
val.NetFields.ReadFull(reader, version);
return(val);
}
public override void ReadFull(BinaryReader reader, NetVersion version)
{
foreach (INetSerializable field in fields)
{
field.ReadFull(reader, version);
}
}
public OutgoingChange(bool removal, TKey key, TField field, NetVersion reassigned)
{
Removal = removal;
Key = key;
Field = field;
Reassigned = reassigned;
}
private void readRemoval(BinaryReader reader, NetVersion version)
{
TKey key = ReadKey(reader);
NetVersion reassign = default(NetVersion);
reassign.Read(reader);
queueIncomingChange(removal: true, key, null, reassign);
}
public override void ReadFull(BinaryReader reader, NetVersion version)
{
int fullValue = reader.ReadInt32();
cleanSet(fullValue);
networkValue = fullValue;
ChangeVersion.Merge(version);
}
public IncomingChange(uint tick, bool removal, TKey key, TField field, NetVersion reassigned)
{
Tick = tick;
Removal = removal;
Key = key;
Field = field;
Reassigned = reassigned;
}
public void Read(BinaryReader reader)
{
NetVersion remoteVersion = default(NetVersion);
remoteVersion.Read(reader);
base.Read(reader, remoteVersion);
Clock.netVersion.Merge(remoteVersion);
}
private T readBaseValue(BinaryReader reader, NetVersion version)
{
if (Serializer != null)
{
return(deserialize(reader));
}
return(ReadType(reader));
}
private void readMultiple(ReadFunc readFunc, BinaryReader reader, NetVersion version)
{
uint count = reader.Read7BitEncoded();
for (uint i = 0u; i < count; i++)
{
readFunc(reader, version);
}
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
T newValue = (T)Enum.ToObject(typeof(T), reader.ReadInt16());
if (version.IsPriorityOver(ChangeVersion))
{
setInterpolationTarget(newValue);
}
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
Guid newValue = reader.ReadGuid();
if (version.IsPriorityOver(ChangeVersion))
{
setInterpolationTarget(newValue);
}
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
int newX = reader.ReadInt32();
int newY = reader.ReadInt32();
if (version.IsPriorityOver(ChangeVersion))
{
setInterpolationTarget(new Point(newX, newY));
}
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
Color newValue = default(Color);
newValue.PackedValue = reader.ReadUInt32();
if (version.IsPriorityOver(ChangeVersion))
{
setInterpolationTarget(newValue);
}
}
private void readDictChange(BinaryReader reader, NetVersion version)
{
if (reader.ReadByte() != 0)
{
readRemoval(reader, version);
}
else
{
readAddition(reader, version);
}
}
private void readAddition(BinaryReader reader, NetVersion version)
{
TKey key = ReadKey(reader);
NetVersion reassign = default(NetVersion);
reassign.Read(reader);
TField field = ReadFieldFull(reader, version);
setFieldParent(field);
queueIncomingChange(removal: false, key, field, reassign);
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
float newX = reader.ReadSingle();
float newY = reader.ReadSingle();
if (version.IsPriorityOver(ChangeVersion))
{
isFixingExtrapolation = isExtrapolating;
setInterpolationTarget(new Vector2(newX, newY));
isExtrapolating = false;
}
}
public override void ReadFull(BinaryReader reader, NetVersion version)
{
reassigned.Read(reader);
T remoteValue = readBaseValue(reader, version);
if (remoteValue != null)
{
ReadValueFull(remoteValue, reader, version);
}
cleanSet(remoteValue);
ChangeVersion.Merge(version);
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
int newX = reader.ReadInt32();
int newY = reader.ReadInt32();
int newWidth = reader.ReadInt32();
int newHeight = reader.ReadInt32();
if (version.IsPriorityOver(ChangeVersion))
{
setInterpolationTarget(new Rectangle(newX, newY, newWidth, newHeight));
}
}
public override void Read(BinaryReader reader, NetVersion version)
{
BitArray dirtyBits = reader.ReadBitArray();
for (int i = 0; i < elements.Count; i++)
{
if (dirtyBits[i])
{
elements[i].Read(reader, version);
}
}
}
public bool Remove(TKey key)
{
if (dict.ContainsKey(key))
{
TField field = dict[key];
NetVersion reassign = dictReassigns[key];
dict.Remove(key);
dictReassigns.Remove(key);
removed(key, field, reassign);
return(true);
}
return(false);
}
private void queueIncomingChange(bool removal, TKey key, TField field, NetVersion fieldReassign)
{
if (!removal)
{
KeyValuePair <NetVersion, TField>?conflict = findConflict(key);
if (conflict.HasValue && !resolveConflict(key, conflict.Value.Value, conflict.Value.Key, field, fieldReassign))
{
return;
}
}
uint timestamp = (uint)((int)GetLocalTick() + ((InterpolationWait && base.Root != null) ? base.Root.Clock.InterpolationTicks : 0));
incomingChanges.Add(new IncomingChange(timestamp, removal, key, field, fieldReassign));
base.NeedsTick = true;
}
public override void Read(BinaryReader reader, NetVersion version)
{
BitArray dirtyBits = reader.ReadBitArray();
if (fields.Count != dirtyBits.Length)
{
throw new InvalidOperationException();
}
for (int i = 0; i < fields.Count; i++)
{
if (dirtyBits[i])
{
fields[i].Read(reader, version);
}
}
}
public override void Read(BinaryReader reader, NetVersion version)
{
uint count = reader.Read7BitEncoded();
uint timestamp = GetLocalTick();
if (InterpolationWait)
{
timestamp = (uint)((int)timestamp + base.Root.Clock.InterpolationTicks);
}
for (uint i = 0u; i < count; i++)
{
uint delay = reader.ReadUInt32();
incomingEvents.Add(new EventRecording(readEventArg(reader, version), timestamp + delay));
}
ChangeVersion.Merge(version);
}
public override void ReadFull(BinaryReader reader, NetVersion version)
{
int size = reader.ReadInt32();
elements.Clear();
for (int i = 0; i < size; i++)
{
TField element = createField(elements.Count);
element.ReadFull(reader, version);
if (base.Parent != null)
{
element.Parent = this;
}
elements.Add(element);
}
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
if (reader.ReadByte() == 1)
{
reader.ReadSkippable(delegate
{
NetVersion other = default(NetVersion);
other.Read(reader);
T val = readBaseValue(reader, version);
if (val != null)
{
ReadValueFull(val, reader, version);
}
if (other.IsIndependent(reassigned))
{
if (!other.IsPriorityOver(reassigned))
{
if (this.OnConflictResolve != null)
{
this.OnConflictResolve(val, targetValue);
}
return;
}
if (this.OnConflictResolve != null)
{
this.OnConflictResolve(targetValue, val);
}
}
else if (!other.IsPriorityOver(reassigned))
{
return;
}
reassigned.Set(other);
setInterpolationTarget(val);
});
}
else
{
reader.ReadSkippable(delegate
{
if (version.IsPrecededBy(reassigned) && targetValue != null)
{
ReadValueDelta(reader, version);
}
});
}
}
protected override void ReadDelta(BinaryReader reader, NetVersion version)
{
string newValue = null;
if (reader.ReadBoolean())
{
newValue = reader.ReadString();
if (this.FilterStringEvent != null)
{
newValue = this.FilterStringEvent(newValue);
}
}
if (version.IsPriorityOver(ChangeVersion))
{
setInterpolationTarget(newValue);
}
}
