HaloMap.Meta.Meta.WriteReferences C# (CSharp) Method

        public void WriteReferences()
        {
            BinaryWriter BW = new BinaryWriter(this.MS);

            for (int xx = 0; xx < this.items.Count; xx++)
            {
                Item i = this.items[xx];

                if (i.intag != this.TagIndex)
                {
                    continue;
                }

                switch (i.type)
                {
                    case ItemType.Reflexive:
                        Reflexive reflex = (Reflexive)i;
                        int newreflex = this.offset + reflex.translation + this.magic;

                        if (reflex.pointstoTagIndex != this.TagIndex)
                        {
                            newreflex = this.Map.MetaInfo.Offset[reflex.pointstoTagIndex] + reflex.translation + this.magic;
                        }

                        BW.BaseStream.Position = reflex.offset;
                        BW.Write(reflex.chunkcount);
                        BW.Write(newreflex);
                        break;

                    case ItemType.Ident:
                        Ident id = (Ident)i;

                        BW.BaseStream.Position = id.offset;
                        BW.Write(id.ident);

                        break;

                    case ItemType.String:
                        String ss = (String)i;
                        byte bleh = 0;
                        BW.BaseStream.Position = ss.offset;
                        BW.Write((short)ss.id);
                        BW.Write(bleh);
                        BW.Write((byte)ss.name.Length);
                        break;
                    default:
                        MessageBox.Show(i.type.ToString());
                        break;
                }
            }
        }

        /// <summary>
        /// The build meta.
        /// </summary>
        /// <param name="metasplit">The metasplit.</param>
        /// <param name="map">The map.</param>
        /// <returns></returns>
        /// <remarks></remarks>
        public static Meta BuildMeta(MetaSplitter metasplit, Map map)
        {
            metasize = 0;
            MetaStream = new MemoryStream(metasplit.Header.chunksize);
            BinaryWriter BW = new BinaryWriter(MetaStream);

            // BW.BaseStream.Position = 0;
            // BW.Write(metasplit.Header.MS.ToArray(), 0, metasplit.Header.chunksize);
            metasize += metasplit.Header.chunksize;

            TagIndex = metasplit.TagIndex;

            Meta m = new Meta(map);

            List<Meta.Item> NewItems = new List<Meta.Item>();

            // Major error here! Size is not calculated right!
            RecursivelyAddPiecesToMeta(metasplit.Header, ref NewItems, ref BW);

            m.items = NewItems;
            if (MetaStream.Length % 4 != 0)
            {
                metasize += (int)MetaStream.Length % 4;
                MetaStream.SetLength(MetaStream.Length + MetaStream.Length % 4);
            }

            m.MS = MetaStream;
            m.size = metasize;
            m.type = metasplit.type;
            m.name = metasplit.name;
            m.rawType = metasplit.rawtype;
            m.raw = metasplit.raw;
            m.magic = metasplit.magic;
            m.offset = metasplit.offset;

            m.TagIndex = TagIndex;
            m.RelinkReferences();
            m.WriteReferences();

            // m.items.Clear();
            // MetaScanner Ms = new MetaScanner();
            if (m.rawType != RawDataContainerType.Empty)
            {
                map.OpenMap(MapTypes.Internal);
                m.raw = map.Functions.ForMeta.ReadRaw(m.TagIndex, false);
                map.CloseMap();
            }

            // map.OpenMap(MapTypes.Internal);
            // IFPIO ifp=IFP.IFPHashMap.GetIfp(m.type);
            // m.parsed = true;
            // Ms.ScanWithIFP(ref ifp, ref m, map) ;
            // map.CloseMap();
            return m;
        }