public override void Deserialize(Bitstream msg)
{
SnapId = msg.ReadUInt32();
BaselineId = msg.ReadUInt32();
ushort count = msg.ReadByte();
Dictionary<int, NetworkObject> state = new Dictionary<int, NetworkObject>();
int addDeltaCount = 0;
for (int i=0; i < count; ++i)
{
ushort objTypeId = msg.ReadByte();
var entId = msg.ReadVariableUInt32();
NetworkObject obj = ObjectMapper.Lookup(entId, objTypeId, true);
if (obj == null)
{
obj = ObjectMapper.Create(entId, objTypeId);
}
NetworkObject realObj = ObjectMapper.Lookup(entId, objTypeId, false);
var realHash = 0;
if (realObj != null)
realHash = realObj.GetHashCode();
NetworkObject baseline = null;
var usebaseLine = msg.ReadBool();
uint bOffset = 0;
if (usebaseLine)
{
byte offset = msg.ReadByte();
var objBaselineId = BaselineId - (uint)offset;
bOffset = objBaselineId;
baseline = ObjectMapper.GetBaseline(objBaselineId, realHash);
}
var ownerType = obj.GetType().GetTypeInfo();
var dItem = DataLookupTable.Get(ownerType);
ReadNetObject(dItem, msg, obj, baseline);
ObjectMapper.AddDeltaState(realHash, SnapId, obj);
if (BaselineId != 0 && realHash != 0)
addDeltaCount++;
}
if (addDeltaCount == count)
ObjectMapper.LastSimId = BaselineId;
}
public override void Deserialize(Bitstream msg)
{
var count = msg.ReadUInt16();
count = (ushort)Math.Max((int)count, 0);
count = (ushort)Math.Min((int)count, 100);
State = new List<PlayerStateData>(count);
if (count > 0)
{
ushort objType = msg.ReadByte();
PlayerId = msg.ReadVariableUInt32();
if (_ownerType == null)
{
_ownerType = ObjectMapper.LookupType(objType);
_lookupItem = DataLookupTable.Get(_ownerType.GetTypeInfo());
}
}
NetworkObject pState = PlayerId > 0 ? ObjectMapper.GetCurrentPlayerState(PlayerId) : null;
for (int i = 0; i < count; ++i)
{
NetworkObject data = Activator.CreateInstance(_ownerType) as NetworkObject;
DataObjectPacket.ReadNetObject(_lookupItem, msg, data, pState);
pState = data;
State.Add(data as PlayerStateData);
}
if (State.Count > 0 && PlayerId > 0)
ObjectMapper.SetCurrentPlayerState(PlayerId, State.Last());
}
public static uint Compute32(Bitstream stream)
{
uint crc = 0xFFFFFFFF;
while (!stream.Eof)
{
byte index = (byte)(((crc) & 0xFF) ^ stream.ReadByte(true));
crc = (uint)((crc >> 8) ^ table[index]);
}
return(~crc);
}
public static uint Compute32(Bitstream stream)
{
uint crc = 0xFFFFFFFF;
while (!stream.Eof)
{
byte index = (byte)(((crc) & 0xFF) ^ stream.ReadByte(true));
crc = (uint)((crc >> 8) ^ table[index]);
}
return ~crc;
}
internal static void ReadNetObject(DataSerializationItem item, Bitstream msg, NetworkObject owner, NetworkObject baseline=null)
{
if (owner is DefinitionNetworkObject)
{
var d = msg.ReadBool();
if (d)
{
(owner as DefinitionNetworkObject).Destroy = true;
return;
}
}
foreach (var prop in item.Properties)
{
var useBaseline = msg.ReadBool();
if (useBaseline)
{
if (baseline != null)
{
ApplyBaseline(prop, owner, baseline);
}
else
{
throw new InvalidOperationException("Can't find baseline!");
}
continue;
}
switch (prop.Type)
{
case DataTypes.BOOL:
prop.Set(owner, msg.ReadBool());
break;
case DataTypes.UBYTE:
prop.Set(owner, msg.ReadByte());
break;
case DataTypes.UINT:
prop.Set(owner, msg.ReadVariableUInt32());
break;
case DataTypes.BYTE:
prop.Set(owner, msg.ReadSByte());
break;
case DataTypes.INT:
prop.Set(owner, msg.ReadVariableInt32());
break;
case DataTypes.ULONG:
prop.Set(owner, msg.ReadUInt64());
break;
case DataTypes.LONG:
prop.Set(owner, msg.ReadInt64());
break;
case DataTypes.FLOAT:
prop.Set(owner, msg.ReadFloat());
break;
case DataTypes.DOUBLE:
prop.Set(owner, msg.ReadDouble());
break;
case DataTypes.STRING:
prop.Set(owner, msg.ReadString());
break;
case DataTypes.VECTOR2:
prop.Set(owner, msg.ReadVector2());
break;
case DataTypes.NETPROP:
var childProp = prop.ChildProperty;
if (childProp != null)
{
var o = (NetworkObject)prop.CreateChildProperty();
if (o != null)
{
var child = (NetworkObject)prop.Get<NetworkObject>(baseline);
ReadNetObject(childProp, msg, o, child);
prop.Set(owner, o);
}
}
break;
}
}
}
private object ReadParam(Bitstream msg)
{
var fullTypeName = msg.ReadString();
var type = LookupType(fullTypeName);
var dsitem = new DataSerializationProperty(null, type);
object o;
switch (dsitem.Type)
{
case DataTypes.BOOL:
o = msg.ReadBool();
break;
case DataTypes.UBYTE:
o = msg.ReadByte();
break;
case DataTypes.UINT:
o = msg.ReadVariableUInt32();
break;
case DataTypes.BYTE:
o = msg.ReadSByte();
break;
case DataTypes.INT:
o = msg.ReadVariableInt32();
break;
case DataTypes.ULONG:
o = msg.ReadUInt64();
break;
case DataTypes.LONG:
o = msg.ReadInt64();
break;
case DataTypes.FLOAT:
o = msg.ReadFloat();
break;
case DataTypes.DOUBLE:
o = msg.ReadDouble();
break;
case DataTypes.STRING:
o = msg.ReadString();
break;
case DataTypes.VECTOR2:
o = msg.ReadVector2();
break;
default:
throw new ArgumentException("Invalid RPC paramter type.");
}
return o;
}
