public static Property getPropOrNull(PCCObject pcc, PCCObject.ExportEntry export, string propName)
{
List <Property> props = getPropList(pcc, export);
foreach (Property prop in props)
{
if (pcc.getNameEntry(prop.Name) == propName)
{
return(prop);
}
}
return(null);
}
public static List <Property> getPropList(PCCObject pcc, PCCObject.ExportEntry export)
{
int start = detectStart(pcc, export.Data, export.ObjectFlags);
return(ReadProp(pcc, export.Data, start));
}
private static PropertyInfo getProperty(PCCObject pcc, PCCObject.ExportEntry entry)
{
PropertyInfo p = new PropertyInfo();
switch (entry.ClassName)
{
case "IntProperty":
p.type = PropertyReader.Type.IntProperty;
break;
case "StringRefProperty":
p.type = PropertyReader.Type.StringRefProperty;
break;
case "FloatProperty":
p.type = PropertyReader.Type.FloatProperty;
break;
case "BoolProperty":
p.type = PropertyReader.Type.BoolProperty;
break;
case "StrProperty":
p.type = PropertyReader.Type.StrProperty;
break;
case "NameProperty":
p.type = PropertyReader.Type.NameProperty;
break;
case "DelegateProperty":
p.type = PropertyReader.Type.DelegateProperty;
break;
case "ObjectProperty":
case "ClassProperty":
case "ComponentProperty":
p.type = PropertyReader.Type.ObjectProperty;
p.reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4));
break;
case "StructProperty":
p.type = PropertyReader.Type.StructProperty;
p.reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4));
break;
case "BioMask4Property":
case "ByteProperty":
p.type = PropertyReader.Type.ByteProperty;
p.reference = pcc.getObjectName(BitConverter.ToInt32(entry.Data, entry.Data.Length - 4));
break;
case "ArrayProperty":
p.type = PropertyReader.Type.ArrayProperty;
PropertyInfo arrayTypeProp = getProperty(pcc, pcc.Exports[BitConverter.ToInt32(entry.Data, 44) - 1]);
if (arrayTypeProp != null)
{
switch (arrayTypeProp.type)
{
case PropertyReader.Type.ObjectProperty:
case PropertyReader.Type.StructProperty:
case PropertyReader.Type.ArrayProperty:
p.reference = arrayTypeProp.reference;
break;
case PropertyReader.Type.ByteProperty:
if (arrayTypeProp.reference == "")
{
p.reference = arrayTypeProp.type.ToString();
}
else
{
p.reference = arrayTypeProp.reference;
}
break;
case PropertyReader.Type.IntProperty:
case PropertyReader.Type.FloatProperty:
case PropertyReader.Type.NameProperty:
case PropertyReader.Type.BoolProperty:
case PropertyReader.Type.StrProperty:
case PropertyReader.Type.StringRefProperty:
case PropertyReader.Type.DelegateProperty:
p.reference = arrayTypeProp.type.ToString();
break;
case PropertyReader.Type.None:
case PropertyReader.Type.Unknown:
default:
System.Diagnostics.Debugger.Break();
p = null;
break;
}
}
else
{
p = null;
}
break;
case "InterfaceProperty":
default:
p = null;
break;
}
return(p);
}
public static byte[] getDefaultClassValue(PCCObject pcc, string className, bool fullProps = false)
{
if (Structs.ContainsKey(className))
{
bool isImmutable = ImmutableStructs.Contains(className);
ClassInfo info = Structs[className];
String pccToLoadPath = Path.Combine(TransplanterLib.GamePath, @"BIOGame\" + info.pccPath);
PCCObject importPCC = null;
pccMemoryCache.TryGetValue(pccToLoadPath, out importPCC);
if (importPCC == null)
{
try
{
importPCC = new PCCObject(pccToLoadPath);
pccMemoryCache[pccToLoadPath] = importPCC;
}
catch (Exception)
{
return(null);
}
}
byte[] buff;
//Plane and CoverReference inherit from other structs, meaning they don't have default values (who knows why)
//thus, I have hardcoded what those default values should be
if (className == "Plane")
{
buff = PlaneDefault;
}
else if (className == "CoverReference")
{
buff = CoverReferenceDefault;
}
else
{
buff = importPCC.Exports[info.exportIndex].Data.Skip(0x24).ToArray();
}
List <PropertyReader.Property> Props = PropertyReader.ReadProp(importPCC, buff, 0);
MemoryStream m = new MemoryStream();
foreach (PropertyReader.Property p in Props)
{
string propName = importPCC.getNameEntry(p.Name);
//check if property is transient, if so, skip (neither of the structs that inherit have transient props)
if (info.properties.ContainsKey(propName) || propName == "None" || info.baseClass != "Class")
{
if (isImmutable && !fullProps)
{
PropertyReader.ImportImmutableProperty(pcc, importPCC, p, className, m, true);
}
else
{
PropertyReader.ImportProperty(pcc, importPCC, p, className, m, true);
}
}
}
return(m.ToArray());
}
else if (Classes.ContainsKey(className))
{
ClassInfo info = Structs[className];
String pccToLoadPath = Path.Combine(TransplanterLib.GamePath, @"BIOGame\" + info.pccPath);
PCCObject importPCC;
if (pccMemoryCache[pccToLoadPath] != null)
{
importPCC = pccMemoryCache[pccToLoadPath];
}
else
{
try
{
importPCC = new PCCObject(pccToLoadPath);
pccMemoryCache[pccToLoadPath] = importPCC;
}
catch (Exception)
{
return(null);
}
}
PCCObject.ExportEntry entry = pcc.Exports[info.exportIndex + 1];
List <PropertyReader.Property> Props = PropertyReader.getPropList(importPCC, entry);
MemoryStream m = new MemoryStream(entry.DataSize - 4);
foreach (PropertyReader.Property p in Props)
{
if (!info.properties.ContainsKey(importPCC.getNameEntry(p.Name)))
{
//property is transient
continue;
}
PropertyReader.ImportProperty(pcc, importPCC, p, className, m);
}
return(m.ToArray());
}
return(null);
}
