Example #1
0
        public void Serialize <TDoc, TCursor>(IO.TagElementStream <TDoc, TCursor, string> s)
            where TDoc : class
            where TCursor : class
        {
            #region MultiplayerEffects (Halo4 only)
            using (var bm = s.EnterCursorBookmarkOpt(kGroupTagMultiplayerEffects, MultiplayerEffects, Predicates.HasItems)) if (bm.IsNotNull)
                {
                    using (s.EnterCursorBookmark("effects"))
                        s.StreamableElements("entry", MultiplayerEffects);
                }
            #endregion

            #region multiplayer_object_type_list
            using (s.EnterCursorBookmark(kGroupTagMultiplayerObjectTypeList))
                ObjectTypeList.Serialize(s);

            Contract.Assert(ObjectTypeList.Types.Count <= mLimits.MultiplayerObjectTypes.MaxCount);
            #endregion

            #region custom_app_globals (Halo4 only)
            using (var bm = s.EnterCursorBookmarkOpt(kGroupTagCustomAppGlobals, CustomApps, Predicates.HasItems)) if (bm.IsNotNull)
                {
                    using (s.EnterCursorBookmark("apps"))
                        s.StreamableElements("entry", CustomApps);
                }
            #endregion

            #region game_globals_ordnance_list (Halo4 only)
            using (var bm = s.EnterCursorBookmarkOpt(kGroupTagGameGlobalsOrdnanceList, OrdnanceList, obj => !obj.IsAvailable)) if (bm.IsNotNull)
                {
                    OrdnanceList.Serialize(s);

                    Contract.Assert(OrdnanceList.Types.Count <= mLimits.GameOrdnanceTypes.MaxCount);
                }
            #endregion

            #region game_medal_globals
            using (s.EnterCursorBookmark(kGroupTagGameMedalGlobals))
                using (s.EnterCursorBookmark("medals"))
                    s.StreamableElements("entry", Medals);

            Contract.Assert(Medals.Count <= mLimits.GameMedals.MaxCount);
            #endregion

            #region incident_globals_definition
            using (s.EnterCursorBookmark(kGroupTagIncidentGlobalsDefinition))
                using (s.EnterCursorBookmark("incidents"))
                    s.StreamableElements("entry", Incidents);

            Contract.Assert(Incidents.Count <= mLimits.GameIncidentTypes.MaxCount);
            #endregion

            #region loadout_globals_definition
            #endregion

            #region megalogamengine_sounds
            using (s.EnterCursorBookmark(kGroupTagMegaloGamEngineSounds))
                using (s.EnterCursorBookmark("sounds"))
                    s.StreamableElements("entry", Sounds);

            Contract.Assert(Sounds.Count == mLimits.MegaloEngineSounds.MaxCount);
            #endregion

            #region megalo_string_id_table
            using (s.EnterCursorBookmark(kGroupTagMegaloStringIdTable))
                using (s.EnterCursorBookmark("names"))
                    s.StreamableElements("entry", Names);

            Contract.Assert(Names.Count <= mLimits.MegaloStringIds.MaxCount);
            #endregion

            #region HudWidgetIcons
            using (s.EnterCursorBookmark("hud_widget_icons"))
                using (s.EnterCursorBookmark("icons"))
                    s.StreamableElements("entry", HudWidgetIcons);

            Contract.Assert(HudWidgetIcons.Count <= mLimits.MegaloHudWidgetIcons.MaxCount);
            #endregion

            #region GameEngineIcons
            using (s.EnterCursorBookmark("engine_icons"))
                using (s.EnterCursorBookmark("icons"))
                    s.StreamableElements("entry", GameEngineIcons);

            Contract.Assert(GameEngineIcons.Count <= mLimits.GameEngineIcons.MaxCount);
            #endregion

            if (s.IsReading)
            {
                MultiplayerEffects.TrimExcess();
                CustomApps.TrimExcess();
                Medals.TrimExcess();
                Incidents.TrimExcess();
                Sounds.TrimExcess();
                Names.TrimExcess();
                HudWidgetIcons.TrimExcess();
                GameEngineIcons.TrimExcess();

                for (int x = 0; x < Sounds.Count; x++)
                {
                    if (Sounds[x].IsAvailable)
                    {
                        continue;
                    }

                    Sounds[x].UpdateForUndefined("MEGALO_SOUND", x);
                }

                for (int x = 0; x < Incidents.Count; x++)
                {
                    if (Incidents[x].IsAvailable)
                    {
                        continue;
                    }

                    Incidents[x].UpdateForUndefined("INCIDENT", x);
                }

                for (int x = 0; x < HudWidgetIcons.Count; x++)
                {
                    if (HudWidgetIcons[x].IsAvailable)
                    {
                        continue;
                    }

                    HudWidgetIcons[x].UpdateForUndefined("HUD_WIDGET", x);
                }

                for (int x = 0; x < GameEngineIcons.Count; x++)
                {
                    if (GameEngineIcons[x].IsAvailable)
                    {
                        continue;
                    }

                    GameEngineIcons[x].UpdateForUndefined("ENGINE_ICON", x);
                }
            }
        }
Example #2
0
 public ObjectTypes()
 {
     Data = new ObjectTypeList();
 }
Example #3
0
        internal void Load(SaveFileReader reader)
        {
            reader.ReadVersion(5);

            var numSequentialScripts = reader.ReadUInt16();

            for (var i = 0; i < numSequentialScripts; i++)
            {
                var sequentialScript = new SequentialScript();
                sequentialScript.Load(reader);
            }

            var numTimersAndCounters = reader.ReadUInt32();

            var unknown2 = reader.ReadUInt32();

            if (unknown2 != 0)
            {
                throw new InvalidDataException();
            }

            for (var i = 1; i < numTimersAndCounters; i++)
            {
                var value  = reader.ReadInt32();
                var name   = reader.ReadAsciiString();
                var active = reader.ReadBoolean();
            }

            var numTimersAndCounters2 = reader.ReadUInt32();

            if (numTimersAndCounters2 != numTimersAndCounters)
            {
                throw new InvalidDataException();
            }

            var numFlags = reader.ReadUInt32();

            for (var i = 1; i < numFlags; i++)
            {
                var value = reader.ReadBoolean();
                var name  = reader.ReadAsciiString();
            }

            var numFlags2 = reader.ReadUInt32();

            if (numFlags2 != numFlags)
            {
                throw new InvalidDataException();
            }

            var numAttackPrioritySets = reader.ReadUInt16();

            reader.__Skip(8); // TODO

            for (var i = 1; i < numAttackPrioritySets; i++)
            {
                var attackPriority = new AttackPriority();
                attackPriority.Load(reader);
            }

            var numAttackPrioritySets2 = reader.ReadUInt32();

            if (numAttackPrioritySets2 != numAttackPrioritySets)
            {
                throw new InvalidDataException();
            }

            var unknown7 = reader.ReadInt32();

            if (unknown7 != -1)
            {
                throw new InvalidDataException();
            }

            var unknown8 = reader.ReadInt32();

            if (unknown8 != -1)
            {
                throw new InvalidDataException();
            }

            var unknownCount = reader.ReadUInt16();

            for (var i = 0; i < unknownCount; i++)
            {
                var objectName = reader.ReadAsciiString();
                var someId     = reader.ReadUInt32();
            }

            var unknown9 = reader.ReadByte();

            if (unknown9 != 0)
            {
                throw new InvalidDataException();
            }

            CameraFadeOverlay.Load(reader);

            reader.__Skip(12);

            var numSpecialPowerSets = reader.ReadUInt16(); // Maybe not sides, maybe player count?

            for (var i = 0; i < numSpecialPowerSets; i++)
            {
                var version = reader.ReadByte();

                var numSpecialPowers = reader.ReadUInt16();
                for (var j = 0; j < numSpecialPowers; j++)
                {
                    var name      = reader.ReadAsciiString();
                    var timestamp = reader.ReadUInt32();
                }
            }

            var numUnknown1Sets = reader.ReadUInt16();

            for (var i = 0; i < numUnknown1Sets; i++)
            {
                var version = reader.ReadByte();

                var count = reader.ReadUInt16();
                if (count != 0)
                {
                    throw new InvalidDataException();
                }
            }

            var numUnknown2Sets = reader.ReadUInt16();

            for (var i = 0; i < numUnknown2Sets; i++)
            {
                var version = reader.ReadByte();

                var count = reader.ReadUInt16();
                if (count != 0)
                {
                    throw new InvalidDataException();
                }
            }

            var numUpgradeSets = reader.ReadUInt16();

            for (var i = 0; i < numUpgradeSets; i++)
            {
                var version = reader.ReadByte();

                var numUpgrades = reader.ReadUInt16();
                for (var j = 0; j < numUpgrades; j++)
                {
                    var name      = reader.ReadAsciiString();
                    var timestamp = reader.ReadUInt32();
                }
            }

            var numScienceSets = reader.ReadUInt16();

            for (var i = 0; i < numScienceSets; i++)
            {
                var version = reader.ReadByte();

                var numSciences = reader.ReadUInt16();
                for (var j = 0; j < numSciences; j++)
                {
                    var name = reader.ReadAsciiString();
                }
            }

            var unknown14_1 = reader.ReadByte();

            if (unknown14_1 != 1)
            {
                throw new InvalidDataException();
            }

            var unknown14_2 = reader.ReadUInt16();

            if (unknown14_2 != 0)
            {
                throw new InvalidDataException();
            }

            for (var i = 0; i < 6; i++)
            {
                var unknown15 = reader.ReadSingle();
            }

            var unknown16 = reader.ReadUInt32();

            if (unknown16 != 150)
            {
                throw new InvalidDataException();
            }

            var unknown17 = reader.ReadUInt32();

            if (unknown17 != 0 && unknown17 != 1 && unknown17 != 2)
            {
                throw new InvalidDataException();
            }

            var unknown18 = reader.ReadByte();

            if (unknown18 != 0)
            {
                throw new InvalidDataException();
            }

            var numMapReveals = reader.ReadUInt16();

            for (var i = 0; i < numMapReveals; i++)
            {
                var revealName = reader.ReadAsciiString();
                var waypoint   = reader.ReadAsciiString();
                var radius     = reader.ReadSingle();
                var player     = reader.ReadAsciiString();
            }

            var numObjectTypeLists = reader.ReadUInt16();

            for (var i = 0; i < numObjectTypeLists; i++)
            {
                var objectTypeList = new ObjectTypeList();
                objectTypeList.Load(reader);
            }

            var unknown20 = reader.ReadByte();

            if (unknown20 != 1)
            {
                throw new InvalidDataException();
            }

            var musicTrack = reader.ReadAsciiString();

            var unknown21 = reader.ReadByte();

            if (unknown21 != 0)
            {
                throw new InvalidDataException();
            }
        }