private MemoryStream toBuffer()
{
int size = sizeof(int);
NameSizeCalculator nameSizer = ArkArchive.GetNameSizer(false);
size += Objects.Sum(o => o.Size(nameSizer));
int propertiesBlockOffset = size;
size += Objects.Sum(o => o.PropertiesSize(nameSizer));
MemoryStream buffer = new MemoryStream(new byte[size], true);
ArkArchive archive = new ArkArchive(buffer);
archive.WriteInt(Objects.Count);
foreach (GameObject gameObject in Objects)
{
propertiesBlockOffset = gameObject.WriteBinary(archive, propertiesBlockOffset);
}
foreach (GameObject gameObject in Objects)
{
gameObject.WriteProperties(archive, 0);
}
return(buffer);
}
public SizeObjectPair(GameObject gameObject, bool ancient, bool hibernation)
{
NameSizeCalculator nameSizer = hibernation ? HIBERNATION_SIZER : ancient ? ANCIENT_SIZER : MODERN_SIZER;
GameObject = gameObject;
Size = gameObject.Size(nameSizer) + gameObject.PropertiesSize(nameSizer);
}
public int GetSizeAndCollectNames()
{
// x y z unkFloat, unkByte, unkInt1 classIndex nameTableSize objectsSize
const int size = sizeof(float) * 4 + 1 + sizeof(int) * 4;
HashSet <string> names = new HashSet <string>();
foreach (GameObject gameObject in Objects)
{
gameObject.CollectPropertyNames(name => names.Add(name.ToString()));
}
NameSizeCalculator objectSizer = ArkArchive.GetNameSizer(false);
NameSizeCalculator propertiesSizer = ArkArchive.GetNameSizer(true, true);
nameTableSize = sizeof(int) * 3;
nameTable = new List <string>(names);
nameTableSize += nameTable.Sum(ArkArchive.GetStringLength);
nameTableSize += ZoneVolumes.Sum(name => objectSizer(name));
objectsSize = sizeof(int);
objectsSize += Objects.Sum(go => go.Size(objectSizer));
propertiesStart = objectsSize;
objectsSize += Objects.Sum(go => go.PropertiesSize(propertiesSizer));
return(size + nameTableSize + objectsSize);
}
public override int CalculateSize(NameSizeCalculator nameSizer)
{
int size = sizeof(int);
size += this.Sum(ArkArchive.GetStringLength);
return(size);
}
public override int CalculateSize(NameSizeCalculator nameSizer)
{
int size = sizeof(int);
size += this.Sum(or => or.Size(nameSizer));
return(size);
}
public int CalculateSize()
{
int size = sizeof(int) + ArkArchive.GetStringLength(className);
NameSizeCalculator nameSizer = ArkArchive.GetNameSizer(false);
size += nameSizer(ArkName.NameNone);
size += Properties.Sum(p => p.CalculateSize(nameSizer));
return(size);
}
public int CalculateSize()
{
int size = sizeof(int);
NameSizeCalculator nameSizer = ArkArchive.GetNameSizer(false);
size += Objects.Sum(o => o.Size(nameSizer));
propertiesBlockOffset = size;
size += Objects.Sum(o => o.PropertiesSize(nameSizer));
return(size);
}
/// <inheritdoc />
/// <summary>
/// Side-effect: calling this function will change the value of the dataSize field.
/// This makes sure that the value can be used by the write function without having to calculate it twice</summary>
/// <param name="nameSizer"></param>
/// <returns></returns>
public int CalculateSize(NameSizeCalculator nameSizer)
{
// dataSize index
int size = sizeof(int) * 2;
DataSize = calculateDataSize(nameSizer);
size += nameSizer(Name);
size += nameSizer(Type);
size += calculateAdditionalSize(nameSizer);
size += DataSize;
return(size);
}
public int CalculateSize(NameSizeCalculator nameSizer)
{
int size = sizeof(int) * 2;
size += sizeof(int) * StructMapList.Count;
foreach (Dictionary <string, StructPropertyList> structMap in StructMapList)
{
foreach (KeyValuePair <string, StructPropertyList> entry in structMap)
{
size += ArkArchive.GetStringLength(entry.Key);
size += entry.Value.Size(nameSizer);
size += sizeof(int);
}
}
return(size);
}
public int Size(NameSizeCalculator nameSizer)
{
switch (ObjectType)
{
case TypeId:
return(Length);
case TypePath:
return(sizeof(int) + nameSizer(ObjectString));
case TypePathNoType:
return(nameSizer(ObjectString));
default:
return(Length);
}
}
public int CalculateSize()
{
// calculateHeaderSize checks for valid known versions
NameSizeCalculator calculator = ArkArchive.GetNameSizer(SaveVersion > 5);
int size = calculateHeaderSize();
size += calculateDataFilesSize();
size += calculateEmbeddedDataSize();
size += calculateDataFilesObjectMapSize();
size += calculateObjectsSize(calculator);
if (SaveVersion > 6)
{
hibernationOffset = size;
size += calculateHibernationSize();
}
if (SaveVersion > 5)
{
nameTableOffset = size;
nameTableForWriteBinary = OldNameList != null ? new ListAppendingSet <string>(OldNameList) : new HashSet <string>();
Objects.ForEach(o => o.CollectNames(arkName => nameTableForWriteBinary.Add(arkName.Name)));
if (OldNameList != null)
{
size += 4 + ((ListAppendingSet <string>)nameTableForWriteBinary).List.Sum(ArkArchive.GetStringLength);
}
else
{
size += 4 + nameTableForWriteBinary.Sum(ArkArchive.GetStringLength);
}
}
else
{
nameTableForWriteBinary = null;
}
propertiesBlockOffset = size;
size += calculateObjectPropertiesSize(calculator);
return(size);
}
/// <summary> /// Calculates the value for the dataSize field /// </summary> /// <param name="nameSizer">function to calculate the size of a name in bytes in the current context</param> /// <returns>value of dataSize field</returns> protected abstract int calculateDataSize(NameSizeCalculator nameSizer);
protected override int calculateAdditionalSize(NameSizeCalculator nameSizer) => nameSizer(Value.Type);
public override int Size(NameSizeCalculator nameSizer) => sizeof(float) * 4;
private int calculateObjectPropertiesSize(NameSizeCalculator nameSizer)
{
return(Objects.AsParallel().Sum(o => o.PropertiesSize(nameSizer)));
}
private int calculateObjectsSize(NameSizeCalculator nameSizer)
{
return(4 + Objects.AsParallel().Sum(o => o.Size(nameSizer)));
}
public override int Size(NameSizeCalculator nameSizer) => sizeof(int) + ArkArchive.GetStringLength(NetId);
protected override int calculateDataSize(NameSizeCalculator nameSizer) => Value.Length;
protected override int calculateDataSize(NameSizeCalculator nameSizer) => nameSizer(Value);
public override int CalculateSize(NameSizeCalculator nameSizer)
{
return(sizeof(int) + this.Sum(abv => nameSizer(abv.NameValue)));
}
protected override int calculateDataSize(NameSizeCalculator nameSizer) => sizeof(byte);
protected override int calculateDataSize(NameSizeCalculator nameSizer) => ArkArchive.GetStringLength(Value);
public override int CalculateSize(NameSizeCalculator nameSizer)
{
return(Count);
}
/// <summary> /// Calculates additional space required to serialize fields of this property. /// </summary> /// <param name="nameSizer"></param> /// <returns></returns> protected virtual int calculateAdditionalSize(NameSizeCalculator nameSizer) => 0;
public int CalculateSize(NameSizeCalculator nameSizer)
{
return(Data?.Length ?? 0);
}
public abstract int CalculateSize(NameSizeCalculator nameSizer);
public override int CalculateSize(NameSizeCalculator nameSizer)
{
return(sizeof(int) + Count * sizeof(short));
}
public int CalculateSize(NameSizeCalculator nameSizer)
{
return(4);
}
public override int Size(NameSizeCalculator nameSizer) => value.Length;
// Special case: value of PropertyBool is not considered "data" protected override int calculateAdditionalSize(NameSizeCalculator nameSizer) => 1;
