// Token: 0x060010C0 RID: 4288 RVA: 0x00016AB0 File Offset: 0x00014CB0
        public static EndOfMatchData Deserialize(Stream bytes)
        {
            int            num            = Int32Proxy.Deserialize(bytes);
            EndOfMatchData endOfMatchData = new EndOfMatchData();

            endOfMatchData.HasWonMatch = BooleanProxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                endOfMatchData.MatchGuid = StringProxy.Deserialize(bytes);
            }
            endOfMatchData.MostEffecientWeaponId = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                endOfMatchData.MostValuablePlayers = ListProxy <StatsSummary> .Deserialize(bytes, new ListProxy <StatsSummary> .Deserializer <StatsSummary>(StatsSummaryProxy.Deserialize));
            }
            if ((num & 4) != 0)
            {
                endOfMatchData.PlayerStatsBestPerLife = StatsCollectionProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                endOfMatchData.PlayerStatsTotal = StatsCollectionProxy.Deserialize(bytes);
            }
            if ((num & 16) != 0)
            {
                endOfMatchData.PlayerXpEarned = DictionaryProxy <byte, ushort> .Deserialize(bytes, new DictionaryProxy <byte, ushort> .Deserializer <byte>(ByteProxy.Deserialize), new DictionaryProxy <byte, ushort> .Deserializer <ushort>(UInt16Proxy.Deserialize));
            }
            endOfMatchData.TimeInGameMinutes = Int32Proxy.Deserialize(bytes);
            return(endOfMatchData);
        }
Beispiel #2
0
        // Token: 0x06001104 RID: 4356 RVA: 0x0001A4F0 File Offset: 0x000186F0
        public static MapView Deserialize(Stream bytes)
        {
            int     num     = Int32Proxy.Deserialize(bytes);
            MapView mapView = new MapView();

            if ((num & 1) != 0)
            {
                mapView.Description = StringProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                mapView.DisplayName = StringProxy.Deserialize(bytes);
            }
            mapView.IsBlueBox         = BooleanProxy.Deserialize(bytes);
            mapView.MapId             = Int32Proxy.Deserialize(bytes);
            mapView.MaxPlayers        = Int32Proxy.Deserialize(bytes);
            mapView.RecommendedItemId = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                mapView.SceneName = StringProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                mapView.Settings = DictionaryProxy <GameModeType, MapSettings> .Deserialize(bytes, new DictionaryProxy <GameModeType, MapSettings> .Deserializer <GameModeType>(EnumProxy <GameModeType> .Deserialize), new DictionaryProxy <GameModeType, MapSettings> .Deserializer <MapSettings>(MapSettingsProxy.Deserialize));
            }
            mapView.SupportedGameModes = Int32Proxy.Deserialize(bytes);
            mapView.SupportedItemClass = Int32Proxy.Deserialize(bytes);
            return(mapView);
        }
Beispiel #3
0
        public static ApplicationConfigurationView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            ApplicationConfigurationView applicationConfigurationView = new ApplicationConfigurationView();

            applicationConfigurationView.MaxLevel              = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.MaxXp                 = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsBaseLoser       = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsBaseWinner      = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsHeadshot        = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsKill            = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsNutshot         = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsPerMinuteLoser  = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsPerMinuteWinner = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.PointsSmackdown       = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpBaseLoser           = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpBaseWinner          = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpHeadshot            = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpKill                = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpNutshot             = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpPerMinuteLoser      = Int32Proxy.Deserialize(bytes);
            applicationConfigurationView.XpPerMinuteWinner     = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                applicationConfigurationView.XpRequiredPerLevel = DictionaryProxy <int, int> .Deserialize(bytes, new DictionaryProxy <int, int> .Deserializer <int>(Int32Proxy.Deserialize), new DictionaryProxy <int, int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            applicationConfigurationView.XpSmackdown = Int32Proxy.Deserialize(bytes);
            return(applicationConfigurationView);
        }
Beispiel #4
0
        // Token: 0x06001109 RID: 4361 RVA: 0x0001A7E8 File Offset: 0x000189E8
        public static void Serialize(Stream stream, PlaySpanHashesViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Hashes != null)
                {
                    DictionaryProxy <decimal, string> .Serialize(memoryStream, instance.Hashes, new DictionaryProxy <decimal, string> .Serializer <decimal>(DecimalProxy.Serialize), new DictionaryProxy <decimal, string> .Serializer <string>(StringProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.MerchTrans != null)
                {
                    StringProxy.Serialize(memoryStream, instance.MerchTrans);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #5
0
        // Token: 0x060010CF RID: 4303 RVA: 0x00017920 File Offset: 0x00015B20
        public static void Serialize(Stream stream, StatsSummary instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Achievements != null)
                {
                    DictionaryProxy <byte, ushort> .Serialize(memoryStream, instance.Achievements, new DictionaryProxy <byte, ushort> .Serializer <byte>(ByteProxy.Serialize), new DictionaryProxy <byte, ushort> .Serializer <ushort>(UInt16Proxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                Int32Proxy.Serialize(memoryStream, instance.Deaths);
                Int32Proxy.Serialize(memoryStream, instance.Kills);
                Int32Proxy.Serialize(memoryStream, instance.Level);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 2;
                }
                EnumProxy <TeamID> .Serialize(memoryStream, instance.Team);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #6
0
        // Token: 0x060010D5 RID: 4309 RVA: 0x00017DB0 File Offset: 0x00015FB0
        public static void Serialize(Stream stream, AccountCompletionResultView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.ItemsAttributed != null)
                {
                    DictionaryProxy <int, int> .Serialize(memoryStream, instance.ItemsAttributed, new DictionaryProxy <int, int> .Serializer <int>(Int32Proxy.Serialize), new DictionaryProxy <int, int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.NonDuplicateNames != null)
                {
                    ListProxy <string> .Serialize(memoryStream, instance.NonDuplicateNames, new ListProxy <string> .Serializer <string>(StringProxy.Serialize));
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.Result);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
 // Token: 0x0600107D RID: 4221 RVA: 0x0001510C File Offset: 0x0001330C
 public static void Serialize(Stream bytes, Dictionary <S, T> instance, DictionaryProxy <S, T> .Serializer <S> keySerialization, DictionaryProxy <S, T> .Serializer <T> valueSerialization)
 {
     Int32Proxy.Serialize(bytes, instance.Count);
     foreach (KeyValuePair <S, T> keyValuePair in instance)
     {
         keySerialization(bytes, keyValuePair.Key);
         valueSerialization(bytes, keyValuePair.Value);
     }
 }
        // Token: 0x0600107E RID: 4222 RVA: 0x00015184 File Offset: 0x00013384
        public static Dictionary <S, T> Deserialize(Stream bytes, DictionaryProxy <S, T> .Deserializer <S> keySerialization, DictionaryProxy <S, T> .Deserializer <T> valueSerialization)
        {
            int num = Int32Proxy.Deserialize(bytes);
            Dictionary <S, T> dictionary = new Dictionary <S, T>(num);

            for (int i = 0; i < num; i++)
            {
                dictionary.Add(keySerialization(bytes), valueSerialization(bytes));
            }
            return(dictionary);
        }
        // Token: 0x060010BF RID: 4287 RVA: 0x00016980 File Offset: 0x00014B80
        public static void Serialize(Stream stream, EndOfMatchData instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                BooleanProxy.Serialize(memoryStream, instance.HasWonMatch);
                if (instance.MatchGuid != null)
                {
                    StringProxy.Serialize(memoryStream, instance.MatchGuid);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.MostEffecientWeaponId);
                if (instance.MostValuablePlayers != null)
                {
                    ListProxy <StatsSummary> .Serialize(memoryStream, instance.MostValuablePlayers, new ListProxy <StatsSummary> .Serializer <StatsSummary>(StatsSummaryProxy.Serialize));
                }
                else
                {
                    num |= 2;
                }
                if (instance.PlayerStatsBestPerLife != null)
                {
                    StatsCollectionProxy.Serialize(memoryStream, instance.PlayerStatsBestPerLife);
                }
                else
                {
                    num |= 4;
                }
                if (instance.PlayerStatsTotal != null)
                {
                    StatsCollectionProxy.Serialize(memoryStream, instance.PlayerStatsTotal);
                }
                else
                {
                    num |= 8;
                }
                if (instance.PlayerXpEarned != null)
                {
                    DictionaryProxy <byte, ushort> .Serialize(memoryStream, instance.PlayerXpEarned, new DictionaryProxy <byte, ushort> .Serializer <byte>(ByteProxy.Serialize), new DictionaryProxy <byte, ushort> .Serializer <ushort>(UInt16Proxy.Serialize));
                }
                else
                {
                    num |= 16;
                }
                Int32Proxy.Serialize(memoryStream, instance.TimeInGameMinutes);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #10
0
        // Token: 0x060010BE RID: 4286 RVA: 0x00016914 File Offset: 0x00014B14
        public static DamageEvent Deserialize(Stream bytes)
        {
            int         num         = Int32Proxy.Deserialize(bytes);
            DamageEvent damageEvent = new DamageEvent();

            damageEvent.BodyPartFlag = ByteProxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                damageEvent.Damage = DictionaryProxy <byte, byte> .Deserialize(bytes, new DictionaryProxy <byte, byte> .Deserializer <byte>(ByteProxy.Deserialize), new DictionaryProxy <byte, byte> .Deserializer <byte>(ByteProxy.Deserialize));
            }
            damageEvent.DamageEffectFlag = Int32Proxy.Deserialize(bytes);
            damageEvent.DamgeEffectValue = SingleProxy.Deserialize(bytes);
            return(damageEvent);
        }
Beispiel #11
0
        // Token: 0x0600110A RID: 4362 RVA: 0x0001A888 File Offset: 0x00018A88
        public static PlaySpanHashesViewModel Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            PlaySpanHashesViewModel playSpanHashesViewModel = new PlaySpanHashesViewModel();

            if ((num & 1) != 0)
            {
                playSpanHashesViewModel.Hashes = DictionaryProxy <decimal, string> .Deserialize(bytes, new DictionaryProxy <decimal, string> .Deserializer <decimal>(DecimalProxy.Deserialize), new DictionaryProxy <decimal, string> .Deserializer <string>(StringProxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                playSpanHashesViewModel.MerchTrans = StringProxy.Deserialize(bytes);
            }
            return(playSpanHashesViewModel);
        }
Beispiel #12
0
        // Token: 0x06001103 RID: 4355 RVA: 0x0001A3C8 File Offset: 0x000185C8
        public static void Serialize(Stream stream, MapView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 1;
                }
                if (instance.DisplayName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.DisplayName);
                }
                else
                {
                    num |= 2;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsBlueBox);
                Int32Proxy.Serialize(memoryStream, instance.MapId);
                Int32Proxy.Serialize(memoryStream, instance.MaxPlayers);
                Int32Proxy.Serialize(memoryStream, instance.RecommendedItemId);
                if (instance.SceneName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.SceneName);
                }
                else
                {
                    num |= 4;
                }
                if (instance.Settings != null)
                {
                    DictionaryProxy <GameModeType, MapSettings> .Serialize(memoryStream, instance.Settings, new DictionaryProxy <GameModeType, MapSettings> .Serializer <GameModeType>(EnumProxy <GameModeType> .Serialize), new DictionaryProxy <GameModeType, MapSettings> .Serializer <MapSettings>(MapSettingsProxy.Serialize));
                }
                else
                {
                    num |= 8;
                }
                Int32Proxy.Serialize(memoryStream, instance.SupportedGameModes);
                Int32Proxy.Serialize(memoryStream, instance.SupportedItemClass);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #13
0
        // Token: 0x060010D6 RID: 4310 RVA: 0x00017E68 File Offset: 0x00016068
        public static AccountCompletionResultView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            AccountCompletionResultView accountCompletionResultView = new AccountCompletionResultView();

            if ((num & 1) != 0)
            {
                accountCompletionResultView.ItemsAttributed = DictionaryProxy <int, int> .Deserialize(bytes, new DictionaryProxy <int, int> .Deserializer <int>(Int32Proxy.Deserialize), new DictionaryProxy <int, int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                accountCompletionResultView.NonDuplicateNames = ListProxy <string> .Deserialize(bytes, new ListProxy <string> .Deserializer <string>(StringProxy.Deserialize));
            }
            accountCompletionResultView.Result = Int32Proxy.Deserialize(bytes);
            return(accountCompletionResultView);
        }
Beispiel #14
0
        // Token: 0x060010FC RID: 4348 RVA: 0x00019A30 File Offset: 0x00017C30
        public static UberStrikeItemQuickView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            UberStrikeItemQuickView uberStrikeItemQuickView = new UberStrikeItemQuickView();

            uberStrikeItemQuickView.BehaviourType = EnumProxy <QuickItemLogic> .Deserialize(bytes);

            uberStrikeItemQuickView.CoolDownTime = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                uberStrikeItemQuickView.CustomProperties = DictionaryProxy <string, string> .Deserialize(bytes, new DictionaryProxy <string, string> .Deserializer <string>(StringProxy.Deserialize), new DictionaryProxy <string, string> .Deserializer <string>(StringProxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                uberStrikeItemQuickView.Description = StringProxy.Deserialize(bytes);
            }
            uberStrikeItemQuickView.ID           = Int32Proxy.Deserialize(bytes);
            uberStrikeItemQuickView.IsConsumable = BooleanProxy.Deserialize(bytes);
            uberStrikeItemQuickView.ItemClass    = EnumProxy <UberstrikeItemClass> .Deserialize(bytes);

            if ((num & 4) != 0)
            {
                uberStrikeItemQuickView.ItemProperties = DictionaryProxy <ItemPropertyType, int> .Deserialize(bytes, new DictionaryProxy <ItemPropertyType, int> .Deserializer <ItemPropertyType>(EnumProxy <ItemPropertyType> .Deserialize), new DictionaryProxy <ItemPropertyType, int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            uberStrikeItemQuickView.LevelLock        = Int32Proxy.Deserialize(bytes);
            uberStrikeItemQuickView.MaxDurationDays  = Int32Proxy.Deserialize(bytes);
            uberStrikeItemQuickView.MaxOwnableAmount = Int32Proxy.Deserialize(bytes);
            if ((num & 8) != 0)
            {
                uberStrikeItemQuickView.Name = StringProxy.Deserialize(bytes);
            }
            if ((num & 16) != 0)
            {
                uberStrikeItemQuickView.PrefabName = StringProxy.Deserialize(bytes);
            }
            if ((num & 32) != 0)
            {
                uberStrikeItemQuickView.Prices = ListProxy <ItemPrice> .Deserialize(bytes, new ListProxy <ItemPrice> .Deserializer <ItemPrice>(ItemPriceProxy.Deserialize));
            }
            uberStrikeItemQuickView.ShopHighlightType = EnumProxy <ItemShopHighlightType> .Deserialize(bytes);

            uberStrikeItemQuickView.UsesPerGame  = Int32Proxy.Deserialize(bytes);
            uberStrikeItemQuickView.UsesPerLife  = Int32Proxy.Deserialize(bytes);
            uberStrikeItemQuickView.UsesPerRound = Int32Proxy.Deserialize(bytes);
            uberStrikeItemQuickView.WarmUpTime   = Int32Proxy.Deserialize(bytes);
            return(uberStrikeItemQuickView);
        }
Beispiel #15
0
        // Token: 0x06001114 RID: 4372 RVA: 0x0001ADB4 File Offset: 0x00018FB4
        public static UberStrikeItemGearView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            UberStrikeItemGearView uberStrikeItemGearView = new UberStrikeItemGearView();

            uberStrikeItemGearView.ArmorPoints = Int32Proxy.Deserialize(bytes);
            uberStrikeItemGearView.ArmorWeight = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                uberStrikeItemGearView.CustomProperties = DictionaryProxy <string, string> .Deserialize(bytes, new DictionaryProxy <string, string> .Deserializer <string>(StringProxy.Deserialize), new DictionaryProxy <string, string> .Deserializer <string>(StringProxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                uberStrikeItemGearView.Description = StringProxy.Deserialize(bytes);
            }
            uberStrikeItemGearView.ID           = Int32Proxy.Deserialize(bytes);
            uberStrikeItemGearView.IsConsumable = BooleanProxy.Deserialize(bytes);
            uberStrikeItemGearView.ItemClass    = EnumProxy <UberstrikeItemClass> .Deserialize(bytes);

            if ((num & 4) != 0)
            {
                uberStrikeItemGearView.ItemProperties = DictionaryProxy <ItemPropertyType, int> .Deserialize(bytes, new DictionaryProxy <ItemPropertyType, int> .Deserializer <ItemPropertyType>(EnumProxy <ItemPropertyType> .Deserialize), new DictionaryProxy <ItemPropertyType, int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            uberStrikeItemGearView.LevelLock       = Int32Proxy.Deserialize(bytes);
            uberStrikeItemGearView.MaxDurationDays = Int32Proxy.Deserialize(bytes);
            if ((num & 8) != 0)
            {
                uberStrikeItemGearView.Name = StringProxy.Deserialize(bytes);
            }
            if ((num & 16) != 0)
            {
                uberStrikeItemGearView.PrefabName = StringProxy.Deserialize(bytes);
            }
            if ((num & 32) != 0)
            {
                uberStrikeItemGearView.Prices = ListProxy <ItemPrice> .Deserialize(bytes, new ListProxy <ItemPrice> .Deserializer <ItemPrice>(ItemPriceProxy.Deserialize));
            }
            uberStrikeItemGearView.ShopHighlightType = EnumProxy <ItemShopHighlightType> .Deserialize(bytes);

            return(uberStrikeItemGearView);
        }
Beispiel #16
0
        // Token: 0x060010D0 RID: 4304 RVA: 0x000179FC File Offset: 0x00015BFC
        public static StatsSummary Deserialize(Stream bytes)
        {
            int          num          = Int32Proxy.Deserialize(bytes);
            StatsSummary statsSummary = new StatsSummary();

            if ((num & 1) != 0)
            {
                statsSummary.Achievements = DictionaryProxy <byte, ushort> .Deserialize(bytes, new DictionaryProxy <byte, ushort> .Deserializer <byte>(ByteProxy.Deserialize), new DictionaryProxy <byte, ushort> .Deserializer <ushort>(UInt16Proxy.Deserialize));
            }
            statsSummary.Cmid   = Int32Proxy.Deserialize(bytes);
            statsSummary.Deaths = Int32Proxy.Deserialize(bytes);
            statsSummary.Kills  = Int32Proxy.Deserialize(bytes);
            statsSummary.Level  = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                statsSummary.Name = StringProxy.Deserialize(bytes);
            }
            statsSummary.Team = EnumProxy <TeamID> .Deserialize(bytes);

            return(statsSummary);
        }
Beispiel #17
0
        // Token: 0x060010BD RID: 4285 RVA: 0x00016870 File Offset: 0x00014A70
        public static void Serialize(Stream stream, DamageEvent instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                ByteProxy.Serialize(memoryStream, instance.BodyPartFlag);
                if (instance.Damage != null)
                {
                    DictionaryProxy <byte, byte> .Serialize(memoryStream, instance.Damage, new DictionaryProxy <byte, byte> .Serializer <byte>(ByteProxy.Serialize), new DictionaryProxy <byte, byte> .Serializer <byte>(ByteProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.DamageEffectFlag);
                SingleProxy.Serialize(memoryStream, instance.DamgeEffectValue);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #18
0
        public static void Serialize(Stream stream, ApplicationConfigurationView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.MaxLevel);
                Int32Proxy.Serialize(memoryStream, instance.MaxXp);
                Int32Proxy.Serialize(memoryStream, instance.PointsBaseLoser);
                Int32Proxy.Serialize(memoryStream, instance.PointsBaseWinner);
                Int32Proxy.Serialize(memoryStream, instance.PointsHeadshot);
                Int32Proxy.Serialize(memoryStream, instance.PointsKill);
                Int32Proxy.Serialize(memoryStream, instance.PointsNutshot);
                Int32Proxy.Serialize(memoryStream, instance.PointsPerMinuteLoser);
                Int32Proxy.Serialize(memoryStream, instance.PointsPerMinuteWinner);
                Int32Proxy.Serialize(memoryStream, instance.PointsSmackdown);
                Int32Proxy.Serialize(memoryStream, instance.XpBaseLoser);
                Int32Proxy.Serialize(memoryStream, instance.XpBaseWinner);
                Int32Proxy.Serialize(memoryStream, instance.XpHeadshot);
                Int32Proxy.Serialize(memoryStream, instance.XpKill);
                Int32Proxy.Serialize(memoryStream, instance.XpNutshot);
                Int32Proxy.Serialize(memoryStream, instance.XpPerMinuteLoser);
                Int32Proxy.Serialize(memoryStream, instance.XpPerMinuteWinner);
                if (instance.XpRequiredPerLevel != null)
                {
                    DictionaryProxy <int, int> .Serialize(memoryStream, instance.XpRequiredPerLevel, new DictionaryProxy <int, int> .Serializer <int>(Int32Proxy.Serialize), new DictionaryProxy <int, int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.XpSmackdown);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #19
0
        // Token: 0x060010FB RID: 4347 RVA: 0x00019844 File Offset: 0x00017A44
        public static void Serialize(Stream stream, UberStrikeItemQuickView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                EnumProxy <QuickItemLogic> .Serialize(memoryStream, instance.BehaviourType);

                Int32Proxy.Serialize(memoryStream, instance.CoolDownTime);
                if (instance.CustomProperties != null)
                {
                    DictionaryProxy <string, string> .Serialize(memoryStream, instance.CustomProperties, new DictionaryProxy <string, string> .Serializer <string>(StringProxy.Serialize), new DictionaryProxy <string, string> .Serializer <string>(StringProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.ID);
                BooleanProxy.Serialize(memoryStream, instance.IsConsumable);
                EnumProxy <UberstrikeItemClass> .Serialize(memoryStream, instance.ItemClass);

                if (instance.ItemProperties != null)
                {
                    DictionaryProxy <ItemPropertyType, int> .Serialize(memoryStream, instance.ItemProperties, new DictionaryProxy <ItemPropertyType, int> .Serializer <ItemPropertyType>(EnumProxy <ItemPropertyType> .Serialize), new DictionaryProxy <ItemPropertyType, int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(memoryStream, instance.LevelLock);
                Int32Proxy.Serialize(memoryStream, instance.MaxDurationDays);
                Int32Proxy.Serialize(memoryStream, instance.MaxOwnableAmount);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 8;
                }
                if (instance.PrefabName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PrefabName);
                }
                else
                {
                    num |= 16;
                }
                if (instance.Prices != null)
                {
                    ListProxy <ItemPrice> .Serialize(memoryStream, instance.Prices, new ListProxy <ItemPrice> .Serializer <ItemPrice>(ItemPriceProxy.Serialize));
                }
                else
                {
                    num |= 32;
                }
                EnumProxy <ItemShopHighlightType> .Serialize(memoryStream, instance.ShopHighlightType);

                Int32Proxy.Serialize(memoryStream, instance.UsesPerGame);
                Int32Proxy.Serialize(memoryStream, instance.UsesPerLife);
                Int32Proxy.Serialize(memoryStream, instance.UsesPerRound);
                Int32Proxy.Serialize(memoryStream, instance.WarmUpTime);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #20
0
        // Token: 0x060010FF RID: 4351 RVA: 0x00019D34 File Offset: 0x00017F34
        public static void Serialize(Stream stream, UberStrikeItemWeaponView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.AccuracySpread);
                //Int32Proxy.Serialize(memoryStream, instance.ArmorPierced);
                Int32Proxy.Serialize(memoryStream, instance.CombatRange);
                Int32Proxy.Serialize(memoryStream, instance.CriticalStrikeBonus);
                if (instance.CustomProperties != null)
                {
                    DictionaryProxy <string, string> .Serialize(memoryStream, instance.CustomProperties, new DictionaryProxy <string, string> .Serializer <string>(StringProxy.Serialize), new DictionaryProxy <string, string> .Serializer <string>(StringProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.DamageKnockback);
                Int32Proxy.Serialize(memoryStream, instance.DamagePerProjectile);
                Int32Proxy.Serialize(memoryStream, instance.DefaultZoomMultiplier);
                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 2;
                }
                BooleanProxy.Serialize(memoryStream, instance.HasAutomaticFire);
                Int32Proxy.Serialize(memoryStream, instance.ID);
                BooleanProxy.Serialize(memoryStream, instance.IsConsumable);
                EnumProxy <UberstrikeItemClass> .Serialize(memoryStream, instance.ItemClass);

                if (instance.ItemProperties != null)
                {
                    DictionaryProxy <ItemPropertyType, int> .Serialize(memoryStream, instance.ItemProperties, new DictionaryProxy <ItemPropertyType, int> .Serializer <ItemPropertyType>(EnumProxy <ItemPropertyType> .Serialize), new DictionaryProxy <ItemPropertyType, int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(memoryStream, instance.LevelLock);
                Int32Proxy.Serialize(memoryStream, instance.MaxAmmo);
                Int32Proxy.Serialize(memoryStream, instance.MaxDurationDays);
                Int32Proxy.Serialize(memoryStream, instance.MaxZoomMultiplier);
                Int32Proxy.Serialize(memoryStream, instance.MinZoomMultiplier);
                Int32Proxy.Serialize(memoryStream, instance.MissileBounciness);
                Int32Proxy.Serialize(memoryStream, instance.MissileForceImpulse);
                Int32Proxy.Serialize(memoryStream, instance.MissileTimeToDetonate);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 8;
                }
                if (instance.PrefabName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PrefabName);
                }
                else
                {
                    num |= 16;
                }
                if (instance.Prices != null)
                {
                    ListProxy <ItemPrice> .Serialize(memoryStream, instance.Prices, new ListProxy <ItemPrice> .Serializer <ItemPrice>(ItemPriceProxy.Serialize));
                }
                else
                {
                    num |= 32;
                }
                Int32Proxy.Serialize(memoryStream, instance.ProjectileSpeed);
                Int32Proxy.Serialize(memoryStream, instance.ProjectilesPerShot);
                Int32Proxy.Serialize(memoryStream, instance.RateOfFire);
                Int32Proxy.Serialize(memoryStream, instance.RecoilKickback);
                Int32Proxy.Serialize(memoryStream, instance.RecoilMovement);
                Int32Proxy.Serialize(memoryStream, instance.SecondaryActionReticle);
                EnumProxy <ItemShopHighlightType> .Serialize(memoryStream, instance.ShopHighlightType);

                Int32Proxy.Serialize(memoryStream, instance.SplashRadius);
                Int32Proxy.Serialize(memoryStream, instance.StartAmmo);
                Int32Proxy.Serialize(memoryStream, instance.Tier);
                Int32Proxy.Serialize(memoryStream, instance.WeaponSecondaryAction);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #21
0
        // Token: 0x06001100 RID: 4352 RVA: 0x00019FE0 File Offset: 0x000181E0
        public static UberStrikeItemWeaponView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            UberStrikeItemWeaponView uberStrikeItemWeaponView = new UberStrikeItemWeaponView();

            uberStrikeItemWeaponView.AccuracySpread = Int32Proxy.Deserialize(bytes);
            //uberStrikeItemWeaponView.ArmorPierced = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.CombatRange         = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.CriticalStrikeBonus = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                uberStrikeItemWeaponView.CustomProperties = DictionaryProxy <string, string> .Deserialize(bytes, new DictionaryProxy <string, string> .Deserializer <string>(StringProxy.Deserialize), new DictionaryProxy <string, string> .Deserializer <string>(StringProxy.Deserialize));
            }
            uberStrikeItemWeaponView.DamageKnockback       = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.DamagePerProjectile   = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.DefaultZoomMultiplier = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                uberStrikeItemWeaponView.Description = StringProxy.Deserialize(bytes);
            }
            uberStrikeItemWeaponView.HasAutomaticFire = BooleanProxy.Deserialize(bytes);
            uberStrikeItemWeaponView.ID           = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.IsConsumable = BooleanProxy.Deserialize(bytes);
            uberStrikeItemWeaponView.ItemClass    = EnumProxy <UberstrikeItemClass> .Deserialize(bytes);

            if ((num & 4) != 0)
            {
                uberStrikeItemWeaponView.ItemProperties = DictionaryProxy <ItemPropertyType, int> .Deserialize(bytes, new DictionaryProxy <ItemPropertyType, int> .Deserializer <ItemPropertyType>(EnumProxy <ItemPropertyType> .Deserialize), new DictionaryProxy <ItemPropertyType, int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            uberStrikeItemWeaponView.LevelLock             = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MaxAmmo               = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MaxDurationDays       = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MaxZoomMultiplier     = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MinZoomMultiplier     = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MissileBounciness     = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MissileForceImpulse   = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.MissileTimeToDetonate = Int32Proxy.Deserialize(bytes);
            if ((num & 8) != 0)
            {
                uberStrikeItemWeaponView.Name = StringProxy.Deserialize(bytes);
            }
            if ((num & 16) != 0)
            {
                uberStrikeItemWeaponView.PrefabName = StringProxy.Deserialize(bytes);
            }
            if ((num & 32) != 0)
            {
                uberStrikeItemWeaponView.Prices = ListProxy <ItemPrice> .Deserialize(bytes, new ListProxy <ItemPrice> .Deserializer <ItemPrice>(ItemPriceProxy.Deserialize));
            }
            uberStrikeItemWeaponView.ProjectileSpeed        = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.ProjectilesPerShot     = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.RateOfFire             = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.RecoilKickback         = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.RecoilMovement         = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.SecondaryActionReticle = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.ShopHighlightType      = EnumProxy <ItemShopHighlightType> .Deserialize(bytes);

            uberStrikeItemWeaponView.SplashRadius          = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.StartAmmo             = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.Tier                  = Int32Proxy.Deserialize(bytes);
            uberStrikeItemWeaponView.WeaponSecondaryAction = Int32Proxy.Deserialize(bytes);

            return(uberStrikeItemWeaponView);
        }
Beispiel #22
0
        // Token: 0x06001113 RID: 4371 RVA: 0x0001AC04 File Offset: 0x00018E04
        public static void Serialize(Stream stream, UberStrikeItemGearView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.ArmorPoints);
                Int32Proxy.Serialize(memoryStream, instance.ArmorWeight);
                if (instance.CustomProperties != null)
                {
                    DictionaryProxy <string, string> .Serialize(memoryStream, instance.CustomProperties, new DictionaryProxy <string, string> .Serializer <string>(StringProxy.Serialize), new DictionaryProxy <string, string> .Serializer <string>(StringProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.ID);
                BooleanProxy.Serialize(memoryStream, instance.IsConsumable);
                EnumProxy <UberstrikeItemClass> .Serialize(memoryStream, instance.ItemClass);

                if (instance.ItemProperties != null)
                {
                    DictionaryProxy <ItemPropertyType, int> .Serialize(memoryStream, instance.ItemProperties, new DictionaryProxy <ItemPropertyType, int> .Serializer <ItemPropertyType>(EnumProxy <ItemPropertyType> .Serialize), new DictionaryProxy <ItemPropertyType, int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(memoryStream, instance.LevelLock);
                Int32Proxy.Serialize(memoryStream, instance.MaxDurationDays);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 8;
                }
                if (instance.PrefabName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PrefabName);
                }
                else
                {
                    num |= 16;
                }
                if (instance.Prices != null)
                {
                    ListProxy <ItemPrice> .Serialize(memoryStream, instance.Prices, new ListProxy <ItemPrice> .Serializer <ItemPrice>(ItemPriceProxy.Serialize));
                }
                else
                {
                    num |= 32;
                }
                EnumProxy <ItemShopHighlightType> .Serialize(memoryStream, instance.ShopHighlightType);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }