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;