public void ReadGuidFieldTest()
{
var reader = new NetBitReader(new byte[] { 0x87, 0x04 });
var export = new NetFieldExport()
{
Handle = 0,
Name = "ItemDefinitionField"
};
var group = new NetFieldExportGroup()
{
PathName = "group1",
NetFieldExportsLength = 1,
NetFieldExports = new NetFieldExport[] { export },
PathNameIndex = 1
};
var guidCache = new NetGuidCache();
var parser = new NetFieldParser(guidCache, ParseMode.Full, "Unreal.Core.Test");
var data = parser.CreateType(group.PathName);
parser.ReadField(data, export, export.Handle, group, reader);
Assert.True(reader.AtEnd());
Assert.False(reader.IsError);
Assert.True(((NetFieldGroup1)data).ItemDefinitionField.IsValid());
Assert.Equal(323u, ((NetFieldGroup1)data).ItemDefinitionField.Value);
}
public void ReadVectorFieldTest()
{
var reader = new NetBitReader(new byte[] { 0x01, 0x0B, 0xC7, 0x47, 0x8A, 0x26, 0xA7, 0xC7, 0x00, 0x80, 0x71, 0xC5 }, 96)
{
NetworkVersion = NetworkVersionHistory.HISTORY_CHARACTER_MOVEMENT_NOINTERP,
EngineNetworkVersion = EngineNetworkVersionHistory.HISTORY_CLASSNETCACHE_FULLNAME
};
var export = new NetFieldExport()
{
Handle = 0,
Name = "VectorField"
};
var group = new NetFieldExportGroup()
{
PathName = "group1",
NetFieldExportsLength = 1,
NetFieldExports = new NetFieldExport[] { export },
PathNameIndex = 1
};
var guidCache = new NetGuidCache();
var parser = new NetFieldParser(guidCache, ParseMode.Full, "Unreal.Core.Test");
var data = parser.CreateType(group.PathName);
parser.ReadField(data, export, export.Handle, group, reader);
Assert.True(reader.AtEnd());
Assert.False(reader.IsError);
Assert.Equal(-3864, ((NetFieldGroup1)data).VectorField.Z);
}
/// <summary>
/// Tries to read the property and update the value accordingly.
/// </summary>
/// <param name="obj"></param>
/// <param name="export"></param>
/// <param name="handle"></param>
/// <param name="exportGroup"></param>
/// <param name="netBitReader"></param>
public void ReadField(object obj, NetFieldExport export, uint handle, NetFieldExportGroup exportGroup, NetBitReader netBitReader)
{
if (!_netFieldGroups.TryGetValue(exportGroup.PathName, out var netGroupInfo))
{
return;
}
NetFieldInfo netFieldInfo;
if (netGroupInfo.UsesHandles)
{
if (!netGroupInfo.Handles.TryGetValue(handle, out netFieldInfo))
{
return;
}
}
else
{
if (!netGroupInfo.Properties.TryGetValue(export.Name, out netFieldInfo))
{
return;
}
}
SetType(obj, exportGroup, netFieldInfo, netBitReader);
}
public void ReadBooleanFieldTest()
{
var reader = new NetBitReader(new byte[] { 0x01 }, 1);
var export = new NetFieldExport()
{
Handle = 0,
Name = "bField"
};
var group = new NetFieldExportGroup()
{
PathName = "group1",
NetFieldExportsLength = 1,
NetFieldExports = new NetFieldExport[] { export },
PathNameIndex = 1
};
var guidCache = new NetGuidCache();
var parser = new NetFieldParser(guidCache, ParseMode.Full, "Unreal.Core.Test");
var data = parser.CreateType(group.PathName);
parser.ReadField(data, export, export.Handle, group, reader);
Assert.True(reader.AtEnd());
Assert.False(reader.IsError);
Assert.True(((NetFieldGroup1)data).bField);
}
private void SetType(object obj, NetFieldExportGroup exportGroup, NetFieldInfo netFieldInfo, NetBitReader netBitReader)
{
var data = netFieldInfo.Attribute.Type switch
{
RepLayoutCmdType.DynamicArray => ReadArrayField(exportGroup, netFieldInfo, netBitReader),
RepLayoutCmdType.RepMovement => netFieldInfo.MovementAttribute != null?netBitReader.SerializeRepMovement(
locationQuantizationLevel : netFieldInfo.MovementAttribute.LocationQuantizationLevel,
rotationQuantizationLevel : netFieldInfo.MovementAttribute.RotationQuantizationLevel,
velocityQuantizationLevel : netFieldInfo.MovementAttribute.VelocityQuantizationLevel) : netBitReader.SerializeRepMovement(),
_ => ReadDataType(netFieldInfo.Attribute.Type, netBitReader, netFieldInfo.PropertyInfo.PropertyType),
};
if (data != null && !netBitReader.IsError)
{
var typeAccessor = TypeAccessor.Create(obj.GetType());
typeAccessor[obj, netFieldInfo.PropertyInfo.Name] = data;
}
}
public static void ReadField(object obj, NetFieldExport export, NetFieldExportGroup exportGroup, uint handle, NetBitReader netBitReader)
{
string group = exportGroup.PathName;
string fixedExportName = FixInvalidNames(export.Name);
if (!_netFieldGroups.ContainsKey(group))
{
AddUnknownField(fixedExportName, export?.Type, group, handle, netBitReader);
return;
}
Type netType = _netFieldGroups[group];
NetFieldGroupInfo netGroupInfo = _netFieldGroupInfo[netType];
if (!netGroupInfo.Properties.ContainsKey(fixedExportName))
{
AddUnknownField(fixedExportName, export?.Type, group, handle, netBitReader);
return;
}
NetFieldInfo netFieldInfo = netGroupInfo.Properties[fixedExportName];
//Update if it finds a higher bit count or an actual type
if (!String.IsNullOrEmpty(export.Type))
{
if (String.IsNullOrEmpty(netFieldInfo.Attribute.Info.Type))
{
AddUnknownField(fixedExportName, export?.Type, group, handle, netBitReader);
}
}
/*else if(netFieldInfo.Attribute.Info.BitCount < netBitReader.GetBitsLeft())
* {
* if(String.IsNullOrEmpty(netFieldInfo.Attribute.Info.Type))
* {
* AddUnknownField(fixedExportName, export?.Type, group, handle, netBitReader);
* }
* }*/
SetType(obj, netType, netFieldInfo, exportGroup, netBitReader);
}
public void ReadArrayFieldTest()
{
var reader = new NetBitReader(new byte[] {
0x0C, 0x02, 0x6F, 0x02, 0x20, 0xD7, 0x08, 0x00, 0x04, 0x6F, 0x02, 0x20, 0xDF, 0x08, 0x00,
0x06, 0x6F, 0x02, 0x20, 0xE7, 0x08, 0x00, 0x08, 0x6F, 0x02, 0x20, 0xEF, 0x08, 0x00, 0x0A,
0x6F, 0x02, 0x20, 0x8F, 0x06, 0x00, 0x0C, 0x6F, 0x02, 0x20, 0xF7, 0x08, 0x00, 0x00
}, 352)
{
NetworkVersion = NetworkVersionHistory.HISTORY_CHARACTER_MOVEMENT_NOINTERP,
EngineNetworkVersion = EngineNetworkVersionHistory.HISTORY_CLASSNETCACHE_FULLNAME
};
var export = new NetFieldExport()
{
Handle = 0,
Name = "ArrayField"
};
var group = new NetFieldExportGroup()
{
PathName = "group1",
NetFieldExportsLength = 183,
NetFieldExports = new NetFieldExport[183],
PathNameIndex = 1
};
group.NetFieldExports[182] = export;
var guidCache = new NetGuidCache();
var parser = new NetFieldParser(guidCache, ParseMode.Full, "Unreal.Core.Test");
var data = parser.CreateType(group.PathName);
parser.ReadField(data, export, export.Handle, group, reader);
Assert.True(reader.AtEnd());
Assert.False(reader.IsError);
Assert.Equal(6, ((NetFieldGroup1)data).ArrayField.Length);
}
/// <summary>
/// see https://github.com/EpicGames/UnrealEngine/blob/5677c544747daa1efc3b5ede31642176644518a6/Engine/Source/Runtime/Engine/Private/RepLayout.cpp#L3141
/// </summary>
private Array ReadArrayField(NetFieldExportGroup netfieldExportGroup, NetFieldInfo fieldInfo, NetBitReader netBitReader)
{
var arrayIndexes = netBitReader.ReadIntPacked();
var elementType = fieldInfo.PropertyInfo.PropertyType.GetElementType();
var isPrimitveType = _primitiveTypeLayout.TryGetValue(elementType, out var replayout);
if (replayout == RepLayoutCmdType.Ignore)
{
return(null);
}
var arr = Array.CreateInstance(elementType, arrayIndexes);
while (true)
{
var index = netBitReader.ReadIntPacked();
if (index == 0)
{
// At this point, the 0 either signifies:
// An array terminator, at which point we're done.
// An array element terminator, which could happen if the array had tailing elements removed.
if (netBitReader.GetBitsLeft() == 8)
{
// We have bits left over, so see if its the Array Terminator.
// This should be 0
var terminator = netBitReader.ReadIntPacked();
if (terminator != 0x00)
{
//Log error
return(arr);
}
}
return(arr);
}
// Shift all indexes down since 0 represents null handle
index--;
if (index >= arrayIndexes)
{
//Log error
return(arr);
}
object data = null;
if (!isPrimitveType)
{
data = _linqCache.CreateObject(elementType);
}
while (true)
{
var handle = netBitReader.ReadIntPacked();
if (handle == 0)
{
break;
}
handle--;
if (netfieldExportGroup.NetFieldExports.Length < handle)
{
return(arr);
}
var export = netfieldExportGroup.NetFieldExports[handle];
var numBits = netBitReader.ReadIntPacked();
if (numBits == 0)
{
continue;
}
if (export == null)
{
netBitReader.SkipBits((int)numBits);
continue;
}
var cmdReader = new NetBitReader(netBitReader.ReadBits(numBits))
{
EngineNetworkVersion = netBitReader.EngineNetworkVersion,
NetworkVersion = netBitReader.NetworkVersion
};
if (!isPrimitveType)
{
ReadField(data, export, handle, netfieldExportGroup, cmdReader);
}
else
{
data = ReadDataType(replayout, cmdReader, elementType);
}
}
arr.SetValue(data, index);
}
}
private static Array ReadArrayField(object obj, NetFieldExportGroup netfieldExportGroup, NetFieldInfo fieldInfo, NetBitReader netBitReader)
{
uint arrayIndexes = netBitReader.ReadIntPacked();
Type elementType = fieldInfo.PropertyInfo.PropertyType.GetElementType();
RepLayoutCmdType replayout = RepLayoutCmdType.Ignore;
NetFieldGroupInfo groupInfo = null;
if (_netFieldGroupInfo.ContainsKey(elementType))
{
groupInfo = _netFieldGroupInfo[elementType];
}
else
{
if (!_primitiveTypeLayout.TryGetValue(elementType, out replayout))
{
replayout = RepLayoutCmdType.Ignore;
}
else
{
if (elementType == typeof(DebuggingObject))
{
}
}
}
Array arr = Array.CreateInstance(elementType, arrayIndexes);
while (true)
{
uint index = netBitReader.ReadIntPacked();
if (index == 0)
{
if (netBitReader.GetBitsLeft() == 8)
{
uint terminator = netBitReader.ReadIntPacked();
if (terminator != 0x00)
{
//Log error
return(arr);
}
}
return(arr);
}
--index;
if (index >= arrayIndexes)
{
//Log error
return(arr);
}
object data = null;
if (groupInfo != null)
{
data = Activator.CreateInstance(elementType);
}
while (true)
{
uint handle = netBitReader.ReadIntPacked();
if (handle == 0)
{
break;
}
handle--;
if (netfieldExportGroup.NetFieldExports.Length < handle)
{
return(arr);
}
NetFieldExport export = netfieldExportGroup.NetFieldExports[handle];
uint numBits = netBitReader.ReadIntPacked();
if (numBits == 0)
{
continue;
}
if (export == null)
{
netBitReader.SkipBits((int)numBits);
continue;
}
NetBitReader cmdReader = new NetBitReader(netBitReader.ReadBits(numBits))
{
EngineNetworkVersion = netBitReader.EngineNetworkVersion,
NetworkVersion = netBitReader.NetworkVersion
};
//Uses the same type for the array
if (groupInfo != null)
{
ReadField(data, export, netfieldExportGroup, handle, cmdReader);
}
else //Probably primitive values
{
data = ReadDataType(replayout, cmdReader, elementType);
}
}
arr.SetValue(data, index);
}
}
private static void SetType(object obj, Type netType, NetFieldInfo netFieldInfo, NetFieldExportGroup exportGroup, NetBitReader netBitReader)
{
object data = null;
switch (netFieldInfo.Attribute.Type)
{
case RepLayoutCmdType.DynamicArray:
data = ReadArrayField(obj, exportGroup, netFieldInfo, netBitReader);
break;
default:
data = ReadDataType(netFieldInfo.Attribute.Type, netBitReader, netFieldInfo.PropertyInfo.PropertyType);
break;
}
if (data != null)
{
TypeAccessor typeAccessor = TypeAccessor.Create(netType);
typeAccessor[obj, netFieldInfo.PropertyInfo.Name] = data;
}
}
