private void SaveDefinitionFixups(IList <ResourceDefinitionFixup> fixups, StructureValueCollection values,
                                          IStream stream, TagBlockCache <ResourceDefinitionFixup> cache)
        {
            var  oldCount   = (int)values.GetIntegerOrDefault("number of definition fixups", 0);
            uint oldAddress = (uint)values.GetIntegerOrDefault("definition fixup table address", 0);

            long oldExpand = _expander.Expand(oldAddress);

            StructureLayout layout = _buildInfo.Layouts.GetLayout("definition fixup element");

            long newAddress;

            if (!cache.TryGetAddress(fixups, out newAddress))
            {
                // Write a new block
                IEnumerable <StructureValueCollection> entries = fixups.Select(f => SerializeDefinitionFixup(f));
                newAddress = TagBlockWriter.WriteTagBlock(entries, oldCount, oldExpand, fixups.Count, layout, _metaArea,
                                                          _allocator, stream);
                cache.Add(newAddress, fixups);
            }
            else if (oldAddress != 0 && oldCount > 0)
            {
                // Block was cached - just free it
                _allocator.Free(oldExpand, oldCount * layout.Size);
            }

            uint cont = _expander.Contract(newAddress);

            values.SetInteger("number of definition fixups", (uint)fixups.Count);
            values.SetInteger("definition fixup table address", cont);
        }
        private void SaveSizeParts(IList <ResourceSizePart> parts, StructureValueCollection values, IStream stream,
                                   TagBlockCache <ResourceSizePart> cache)
        {
            var  oldCount   = (int)values.GetIntegerOrDefault("number of size parts", 0);
            uint oldAddress = (uint)values.GetIntegerOrDefault("size part table address", 0);

            long expand = _expander.Expand(oldAddress);

            StructureLayout layout = _buildInfo.Layouts.GetLayout("size part table element");

            long newAddress;

            if (!cache.TryGetAddress(parts, out newAddress))
            {
                // Write a new block
                IEnumerable <StructureValueCollection> entries = parts.Select(p => SerializeSizePart(p));
                newAddress = TagBlockWriter.WriteTagBlock(entries, oldCount, expand, parts.Count, layout, _metaArea,
                                                          _allocator, stream);
                cache.Add(newAddress, parts);
            }
            else if (oldAddress != 0 && oldCount > 0)
            {
                // Block was cached - just free it
                _allocator.Free(expand, oldCount * layout.Size);
            }

            uint cont = _expander.Contract(newAddress);

            values.SetInteger("number of size parts", (uint)parts.Count);
            values.SetInteger("size part table address", cont);
        }
        public void SaveSizes(ICollection <ResourceSize> sizes, IStream stream)
        {
            StructureValueCollection values = LoadTag(stream);

            var entries   = new List <StructureValueCollection>();
            var partCache = new TagBlockCache <ResourceSizePart>();

            foreach (ResourceSize size in sizes)
            {
                StructureValueCollection entry = SerializeSize(size);
                entries.Add(entry);
                SaveSizeParts(size.Parts, entry, stream, partCache);
            }


            StructureLayout layout     = _buildInfo.Layouts.GetLayout("raw size table element");
            var             oldCount   = (int)values.GetInteger("number of raw sizes");
            uint            oldAddress = (uint)values.GetInteger("raw size table address");

            long expand = _expander.Expand(oldAddress);

            long newAddress = TagBlockWriter.WriteTagBlock(entries, oldCount, expand, sizes.Count, layout, _metaArea,
                                                           _allocator, stream);

            // Update values
            uint cont = _expander.Contract(newAddress);

            values.SetInteger("number of raw sizes", (uint)sizes.Count);
            values.SetInteger("raw size table address", cont);
            SaveTag(values, stream);
        }
        /// <summary>
        ///     Saves changes made to zone sets in the table.
        /// </summary>
        /// <param name="stream">The stream to write to.</param>
        /// <exception cref="System.NotImplementedException"></exception>
        public void SaveChanges(IStream stream)
        {
            StructureValueCollection tagValues = _gestalt.LoadTag(stream);

            FreeZoneSets(tagValues, stream);

            var cache = new TagBlockCache <int>();

            SaveZoneSetTable(GlobalZoneSet, tagValues, "number of global zone sets", "global zone set table address", cache, stream);
            SaveZoneSetTable(UnattachedZoneSet, tagValues, "number of unattached zone sets", "unattached zone set table address", cache, stream);
            SaveZoneSetTable(DiscForbiddenZoneSet, tagValues, "number of disc forbidden zone sets", "disc forbidden zone set table address", cache, stream);
            SaveZoneSetTable(DiscAlwaysStreamingZoneSet, tagValues, "number of disc always streaming zone sets", "disc always streaming zone set table address", cache, stream);
            SaveZoneSetTable(RequiredMapVariantsZoneSet, tagValues, "number of required map variant zone sets", "required map variant zone set table address", cache, stream);
            SaveZoneSetTable(SandboxMapVariantsZoneSet, tagValues, "number of sandbox map variant zone sets", "sandbox map variant zone set table address", cache, stream);
            SaveZoneSetTable(GeneralZoneSets, tagValues, "number of general zone sets", "general zone set table address", cache, stream);
            SaveZoneSetTable(BSPZoneSets, tagValues, "number of bsp zone sets", "bsp zone set table address", cache, stream);
            SaveZoneSetTable(BSPZoneSets2, tagValues, "number of bsp 2 zone sets", "bsp 2 zone set table address", cache, stream);
            SaveZoneSetTable(BSPZoneSets3, tagValues, "number of bsp 3 zone sets", "bsp 3 zone set table address", cache, stream);
            SaveZoneSetTable(CinematicZoneSets, tagValues, "number of cinematic zone sets", "cinematic zone set table address", cache, stream);
            SaveZoneSetTable(ScenarioZoneSets, tagValues, "number of scenario zone sets", "scenario zone set table address", cache, stream);

            _gestalt.SaveTag(tagValues, stream);
        }
        private void SaveZoneSetTable(IZoneSet[] sets, StructureValueCollection tagValues, string countName, string addressName, TagBlockCache <int> cache, IStream stream)
        {
            if (!tagValues.HasInteger(countName) || !tagValues.HasInteger(addressName))
            {
                return;
            }

            var count = (int)tagValues.GetInteger(countName);

            if (count != sets.Length)
            {
                throw new InvalidOperationException("Zone set count does not match");
            }

            uint address = (uint)tagValues.GetInteger(addressName);

            long expand = _expander.Expand(address);

            StructureLayout layout = _buildInfo.Layouts.GetLayout("zone set definition");
            List <StructureValueCollection> entries =
                sets.Select(set => ((ThirdGenZoneSet)set).Serialize(stream, _allocator, cache, _expander)).ToList();

            TagBlockWriter.WriteTagBlock(entries, expand, layout, _metaArea, stream);
        }
 private void SaveZoneSetTable(IZoneSet set, StructureValueCollection tagValues, string countName, string addressName, TagBlockCache <int> cache, IStream stream)
 {
     SaveZoneSetTable(new[] { set }, tagValues, countName, addressName, cache, stream);
 }
        public IList <ResourcePointer> SaveResources(ICollection <Resource> resources, IStream stream)
        {
            StructureValueCollection values = LoadTag(stream);
            StructureLayout          layout = _buildInfo.Layouts.GetLayout("resource table element");

            FreeResources(values, stream);
            FreeInfoBuffer(values);

            // Serialize each resource element
            // This can't be lazily evaluated because allocations might cause the stream to expand
            int infoOffset    = 0;
            int altInfoOffset = 0;
            var infocache     = new TagBlockCache <int>();

            var pointers      = new List <ResourcePointer>();
            var entries       = new List <StructureValueCollection>();
            var fixupCache    = new TagBlockCache <ResourceFixup>();
            var defFixupCache = new TagBlockCache <ResourceDefinitionFixup>();

            List <byte[]> paddedInfos = new List <byte[]>();

            foreach (Resource resource in resources)
            {
                StructureValueCollection entry = SerializeResource(resource, (resource.Location != null) ? pointers.Count : -1, stream);
                entries.Add(entry);

                // Save fixups
                SaveResourceFixups(resource.ResourceFixups, entry, stream, fixupCache);
                SaveDefinitionFixups(resource.DefinitionFixups, entry, stream, defFixupCache);

                uint bits = (uint)entry.GetInteger("resource bits");
                int  size = (int)entry.GetInteger("resource info size");

                List <int> offsets = new List <int>();

                if (size > 0)
                {
                    int dirtyoffset = infoOffset;

                    infoOffset = AlignInfoBlockOffset(resource, infoOffset);

                    offsets.Add(infoOffset);

                    int padding = infoOffset - dirtyoffset;

                    byte[] temp = new byte[padding + size];

                    Buffer.BlockCopy(resource.Info, 0, temp, padding, size);

                    paddedInfos.Add(temp);

                    infoOffset += size;
                }
                else
                {
                    offsets.Add(0);
                }

                if ((bits & 2) > 0)
                {
                    int tempalt = AlignInfoBlockOffset(resource, altInfoOffset);
                    offsets.Add(tempalt);

                    altInfoOffset += size;
                }
                else
                {
                    offsets.Add(size > 0 ? -1 : 0);
                }

                if ((bits & 4) > 0)
                {
                    int tempalt = AlignInfoBlockOffset(resource, altInfoOffset);
                    offsets.Add(tempalt);

                    altInfoOffset += size;
                }
                else
                {
                    offsets.Add(size > 0 ? -1 : 0);
                }

                if (layout.HasField("number of resource info offsets"))
                {
                    var  oldCount   = (int)entry.GetIntegerOrDefault("number of resource info offsets", 0);
                    uint oldAddress = (uint)entry.GetIntegerOrDefault("resource info offsets table address", 0);

                    long expand = _expander.Expand(oldAddress);

                    StructureLayout infolayout = _buildInfo.Layouts.GetLayout("resource info offset element");

                    if (size > 0)
                    {
                        long newBlockAddress;

                        // Write a new block
                        IEnumerable <StructureValueCollection> infoentries = offsets.Select(f => SerializeInfos(f));
                        newBlockAddress = TagBlockWriter.WriteTagBlock(infoentries, oldCount, expand, offsets.Count, infolayout, _metaArea,
                                                                       _allocator, stream);
                        infocache.Add(newBlockAddress, offsets);

                        uint cont = _expander.Contract(newBlockAddress);

                        entry.SetInteger("number of resource info offsets", (uint)offsets.Count);
                        entry.SetInteger("resource info offsets table address", cont);
                    }
                    else
                    {
                        entry.SetInteger("number of resource info offsets", 0);
                        entry.SetInteger("resource info offsets table address", 0);
                    }
                }
                else
                {
                    if (size > 0)
                    {
                        entry.SetInteger("resource info offset", (uint)offsets[0]);
                        entry.SetInteger("alt resource info offset", (uint)offsets[1]);
                    }
                    else
                    {
                        entry.SetInteger("resource info offset", 0);
                        entry.SetInteger("alt resource info offset", 0);
                    }
                }

                // Update pointer info
                if (resource.Location != null)
                {
                    pointers.Add(resource.Location);
                }
            }

            // Write the block and update the tag values
            long newAddress = TagBlockWriter.WriteTagBlock(entries, layout, _metaArea, _allocator, stream);

            uint contr = _expander.Contract(newAddress);

            values.SetInteger("number of resources", (uint)entries.Count);
            values.SetInteger("resource table address", contr);

            // Save the info buffer
            SaveResourceInfoBuffer(paddedInfos.SelectMany(a => a).ToArray(), values, stream);

            SaveTag(values, stream);
            return(pointers);
        }
Example #8
0
        private void SaveBitArray(BitArray bits, string countName, string addressName, MetaAllocator allocator, IStream stream, TagBlockCache <int> cache, StructureValueCollection values, IPointerExpander expander)
        {
            if (bits.Length == 0)
            {
                values.SetInteger(countName, 0);
                values.SetInteger(addressName, 0);
                return;
            }

            var ints = bits.ToIntArray();

            // If the address isn't cached, then allocate space and write a new array
            long newAddress;

            if (!cache.TryGetAddress(ints, out newAddress))
            {
                newAddress = allocator.Allocate(ints.Length * 4, stream);
                stream.SeekTo(_metaArea.PointerToOffset(newAddress));
                foreach (int i in ints)
                {
                    stream.WriteInt32(i);
                }

                cache.Add(newAddress, ints);
            }

            uint cont = expander.Contract(newAddress);

            values.SetInteger(countName, (uint)ints.Length);
            values.SetInteger(addressName, cont);
        }
Example #9
0
        public StructureValueCollection Serialize(IStream stream, MetaAllocator allocator, TagBlockCache <int> cache, IPointerExpander expander)
        {
            var result = new StructureValueCollection();

            SaveBitArray(_activeResources, "number of raw pool flags", "raw pool flag table address", allocator, stream, cache, result, expander);
            SaveBitArray(_unknownResources, "number of raw pool 2 flags", "raw pool 2 flag table address", allocator, stream, cache, result, expander);
            SaveBitArray(_unknownResources2, "number of raw pool 3 flags", "raw pool 3 flag table address", allocator, stream, cache, result, expander);
            SaveBitArray(_activeTags, "number of tag flags", "tag flag table address", allocator, stream, cache, result, expander);
            SaveBitArray(_unknownTags, "number of tag 2 flags", "tag 2 flag table address", allocator, stream, cache, result, expander);
            return(result);
        }