|
public static getPropertyInfo ( string className, string propName, bool inStruct = false ) : |
||
| className | string | |
| propName | string | |
| inStruct | bool | |
| return | ||
/// <summary>
/// Gets property information for a property by name & containing class or struct name
/// </summary>
/// <param name="game">Game to lookup informatino from</param>
/// <param name="propname">Name of property information to look up</param>
/// <param name="containingClassOrStructName">Name of containing class or struct name</param>
/// <param name="nonVanillaClassInfo">Dynamically built property info</param>
/// <returns></returns>
public static PropertyInfo GetPropertyInfo(MEGame game, string propname, string containingClassOrStructName, ClassInfo nonVanillaClassInfo = null)
{
bool inStruct = false;
PropertyInfo p = null;
switch (game)
{
case MEGame.ME1:
p = ME1UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct, nonVanillaClassInfo);
break;
case MEGame.ME2:
p = ME2UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct, nonVanillaClassInfo);
break;
case MEGame.ME3:
case MEGame.UDK:
p = ME3UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct, nonVanillaClassInfo);
if (p == null && game == MEGame.UDK)
{
p = UDKUnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct, nonVanillaClassInfo);
}
break;
}
if (p == null)
{
inStruct = true;
switch (game)
{
case MEGame.ME1:
p = ME1UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct);
break;
case MEGame.ME2:
p = ME2UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct);
break;
case MEGame.ME3:
p = ME3UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct);
break;
case MEGame.UDK:
p = ME3UnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct);
if (p == null && game == MEGame.UDK)
{
p = UDKUnrealObjectInfo.getPropertyInfo(containingClassOrStructName, propname, inStruct, nonVanillaClassInfo);
}
break;
}
}
return(p);
}
public static PropertyInfo GetPropertyInfo(MEGame game, string propname, string typeName)
{
bool inStruct = false;
PropertyInfo p = null;
switch (game)
{
case MEGame.ME1:
p = ME1UnrealObjectInfo.getPropertyInfo(typeName, propname, inStruct);
break;
case MEGame.ME2:
p = ME2UnrealObjectInfo.getPropertyInfo(typeName, propname, inStruct);
break;
case MEGame.ME3:
p = ME3UnrealObjectInfo.getPropertyInfo(typeName, propname, inStruct);
break;
}
if (p == null)
{
inStruct = true;
switch (game)
{
case MEGame.ME1:
p = ME1UnrealObjectInfo.getPropertyInfo(typeName, propname, inStruct);
break;
case MEGame.ME2:
p = ME2UnrealObjectInfo.getPropertyInfo(typeName, propname, inStruct);
break;
case MEGame.ME3:
p = ME3UnrealObjectInfo.getPropertyInfo(typeName, propname, inStruct);
break;
}
}
return(p);
}
public static void ImportProperty(IMEPackage pcc, IMEPackage importpcc, Property p, string className, MemoryStream m, bool inStruct = false)
{
string name = importpcc.getNameEntry(p.Name);
int idxname = pcc.FindNameOrAdd(name);
m.Write(BitConverter.GetBytes(idxname), 0, 4);
m.Write(new byte[4], 0, 4);
if (name == "None")
{
return;
}
string type = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 8));
int idxtype = pcc.FindNameOrAdd(type);
m.Write(BitConverter.GetBytes(idxtype), 0, 4);
m.Write(new byte[4], 0, 4);
string name2;
int idxname2;
int size, count, pos;
List <Property> Props;
switch (type)
{
case "IntProperty":
case "FloatProperty":
case "ObjectProperty":
case "StringRefProperty":
m.Write(BitConverter.GetBytes(4), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(p.Value.IntValue), 0, 4);
break;
case "NameProperty":
m.Write(BitConverter.GetBytes(8), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(pcc.FindNameOrAdd(importpcc.getNameEntry(p.Value.IntValue))), 0, 4);
//preserve index or whatever the second part of a namereference is
m.Write(p.raw, 28, 4);
break;
case "BoolProperty":
m.Write(new byte[8], 0, 8);
m.WriteByte((byte)p.Value.IntValue);
if (pcc.Game != MEGame.ME3)
{
m.Write(new byte[3], 0, 3);
}
break;
case "BioMask4Property":
m.Write(BitConverter.GetBytes(p.Size), 0, 4);
m.Write(new byte[4], 0, 4);
m.WriteByte((byte)p.Value.IntValue);
break;
case "ByteProperty":
m.Write(BitConverter.GetBytes(p.Size), 0, 4);
m.Write(new byte[4], 0, 4);
if (pcc.Game == MEGame.ME3)
{
name2 = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 24));
idxname2 = pcc.FindNameOrAdd(name2);
m.Write(BitConverter.GetBytes(idxname2), 0, 4);
m.Write(new byte[4], 0, 4);
}
if (p.Size != 1)
{
m.Write(BitConverter.GetBytes(pcc.FindNameOrAdd(importpcc.getNameEntry(p.Value.IntValue))), 0, 4);
m.Write(new byte[4], 0, 4);
}
else
{
m.WriteByte(Convert.ToByte(p.Value.IntValue));
}
break;
case "DelegateProperty":
size = BitConverter.ToInt32(p.raw, 16);
if (size == 0xC)
{
name2 = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 28));
idxname2 = pcc.FindNameOrAdd(name2);
m.Write(BitConverter.GetBytes(0xC), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(idxname2), 0, 4);
m.Write(new byte[4], 0, 4);
}
else
{
m.Write(BitConverter.GetBytes(size), 0, 4);
m.Write(new byte[4], 0, 4);
for (int i = 0; i < size; i++)
{
m.WriteByte(p.raw[24 + i]);
}
}
break;
case "StrProperty":
name2 = p.Value.StringValue;
if (p.Value.StringValue.Length > 0)
{
name2 += '\0';
}
if (p.Value.len < 0)
{
//unicode
m.Write(BitConverter.GetBytes(4 + name2.Length * 2), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(-name2.Length), 0, 4);
foreach (char c in name2)
{
m.WriteByte((byte)c);
m.WriteByte(0);
}
}
else
{
//ascii
m.Write(BitConverter.GetBytes(4 + name2.Length), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(name2.Length), 0, 4);
foreach (char c in name2)
{
m.WriteByte((byte)c);
}
}
break;
case "StructProperty":
size = BitConverter.ToInt32(p.raw, 16);
name2 = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 24));
idxname2 = pcc.FindNameOrAdd(name2);
pos = 32;
Props = new List <Property>();
try
{
Props = ReadProp(importpcc, p.raw, pos);
}
catch (Exception)
{
}
m.Write(BitConverter.GetBytes(size), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(idxname2), 0, 4);
m.Write(new byte[4], 0, 4);
if (Props.Count == 0 || Props[0].TypeVal == PropertyType.Unknown)
{
for (int i = 0; i < size; i++)
{
m.WriteByte(p.raw[32 + i]);
}
}
else
{
foreach (Property pp in Props)
{
ImportProperty(pcc, importpcc, pp, className, m, inStruct);
}
}
break;
case "ArrayProperty":
size = BitConverter.ToInt32(p.raw, 16);
count = BitConverter.ToInt32(p.raw, 24);
PropertyInfo info = ME3UnrealObjectInfo.getPropertyInfo(className, name, inStruct);
ArrayType arrayType = ME3UnrealObjectInfo.getArrayType(info);
pos = 28;
List <Property> AllProps = new List <Property>();
if (arrayType == ArrayType.Struct)
{
for (int i = 0; i < count; i++)
{
Props = new List <Property>();
try
{
Props = ReadProp(importpcc, p.raw, pos);
}
catch (Exception)
{
}
AllProps.AddRange(Props);
if (Props.Count != 0)
{
pos = Props[Props.Count - 1].offend;
}
}
}
m.Write(BitConverter.GetBytes(size), 0, 4);
m.Write(new byte[4], 0, 4);
m.Write(BitConverter.GetBytes(count), 0, 4);
if (AllProps.Count != 0 && (info == null || !UnrealObjectInfo.isImmutable(info.reference, pcc.Game)))
{
foreach (Property pp in AllProps)
{
ImportProperty(pcc, importpcc, pp, className, m, inStruct);
}
}
else if (arrayType == ArrayType.Name)
{
for (int i = 0; i < count; i++)
{
string s = importpcc.getNameEntry(BitConverter.ToInt32(p.raw, 28 + i * 8));
m.Write(BitConverter.GetBytes(pcc.FindNameOrAdd(s)), 0, 4);
//preserve index or whatever the second part of a namereference is
m.Write(p.raw, 32 + i * 8, 4);
}
}
else
{
m.Write(p.raw, 28, size - 4);
}
break;
default:
throw new Exception(type);
}
}
