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);
        }
Exemplo n.º 2
0
        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);
        }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
0
        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);
        }
Exemplo n.º 5
0
        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);
        }