// Token: 0x06001112 RID: 4370 RVA: 0x0001ABBC File Offset: 0x00018DBC
        public static RegisterClientApplicationViewModel Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            RegisterClientApplicationViewModel registerClientApplicationViewModel = new RegisterClientApplicationViewModel();

            if ((num & 1) != 0)
            {
                registerClientApplicationViewModel.ItemsAttributed = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            registerClientApplicationViewModel.Result = EnumProxy <ApplicationRegistrationResult> .Deserialize(bytes);

            return(registerClientApplicationViewModel);
        }
示例#2
0
        // Token: 0x06001059 RID: 4185 RVA: 0x00013D34 File Offset: 0x00011F34
        public static void Serialize(Stream stream, LuckyDrawUnityView instance)
        {
            int num = 0;

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

                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 1;
                }
                if (instance.IconUrl != null)
                {
                    StringProxy.Serialize(memoryStream, instance.IconUrl);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.Id);
                BooleanProxy.Serialize(memoryStream, instance.IsAvailableInShop);
                if (instance.LuckyDrawSets != null)
                {
                    ListProxy <LuckyDrawSetUnityView> .Serialize(memoryStream, instance.LuckyDrawSets, new ListProxy <LuckyDrawSetUnityView> .Serializer <LuckyDrawSetUnityView>(LuckyDrawSetUnityViewProxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 8;
                }
                Int32Proxy.Serialize(memoryStream, instance.Price);
                EnumProxy <UberStrikeCurrencyType> .Serialize(memoryStream, instance.UberStrikeCurrencyType);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#3
0
        // Token: 0x0600104A RID: 4170 RVA: 0x000131B8 File Offset: 0x000113B8
        public static ContactGroupView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            ContactGroupView contactGroupView = new ContactGroupView();

            if ((num & 1) != 0)
            {
                contactGroupView.Contacts = ListProxy <PublicProfileView> .Deserialize(bytes, new ListProxy <PublicProfileView> .Deserializer <PublicProfileView>(PublicProfileViewProxy.Deserialize));
            }
            contactGroupView.GroupId = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                contactGroupView.GroupName = StringProxy.Deserialize(bytes);
            }
            return(contactGroupView);
        }
示例#4
0
        // Token: 0x060010B8 RID: 4280 RVA: 0x00016550 File Offset: 0x00014750
        public static MatchStats Deserialize(Stream bytes)
        {
            int        num        = Int32Proxy.Deserialize(bytes);
            MatchStats matchStats = new MatchStats();

            matchStats.GameModeId = EnumProxy <GameModeType> .Deserialize(bytes);

            matchStats.MapId = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                matchStats.Players = ListProxy <PlayerMatchStats> .Deserialize(bytes, new ListProxy <PlayerMatchStats> .Deserializer <PlayerMatchStats>(PlayerMatchStatsProxy.Deserialize));
            }
            matchStats.PlayersLimit = Int32Proxy.Deserialize(bytes);
            matchStats.TimeLimit    = Int32Proxy.Deserialize(bytes);
            return(matchStats);
        }
示例#5
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);
        }
示例#6
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);
        }
示例#7
0
        // Token: 0x0600106C RID: 4204 RVA: 0x000149C4 File Offset: 0x00012BC4
        public static PackageView Deserialize(Stream bytes)
        {
            int         num         = Int32Proxy.Deserialize(bytes);
            PackageView packageView = new PackageView();

            packageView.Bonus = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                packageView.Items = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                packageView.Name = StringProxy.Deserialize(bytes);
            }
            packageView.Price = DecimalProxy.Deserialize(bytes);
            return(packageView);
        }
示例#8
0
        // Token: 0x06001115 RID: 4373 RVA: 0x0001AEE8 File Offset: 0x000190E8
        public static void Serialize(Stream stream, UberstrikeLevelViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Maps != null)
                {
                    ListProxy <MapView> .Serialize(memoryStream, instance.Maps, new ListProxy <MapView> .Serializer <MapView>(MapViewProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#9
0
        // Token: 0x060010D7 RID: 4311 RVA: 0x00017EDC File Offset: 0x000160DC
        public static void Serialize(Stream stream, AuthenticateApplicationView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.CommServer != null)
                {
                    PhotonViewProxy.Serialize(memoryStream, instance.CommServer);
                }
                else
                {
                    num |= 1;
                }
                if (instance.EncryptionInitVector != null)
                {
                    StringProxy.Serialize(memoryStream, instance.EncryptionInitVector);
                }
                else
                {
                    num |= 2;
                }
                if (instance.EncryptionPassPhrase != null)
                {
                    StringProxy.Serialize(memoryStream, instance.EncryptionPassPhrase);
                }
                else
                {
                    num |= 4;
                }
                if (instance.GameServers != null)
                {
                    ListProxy <PhotonView> .Serialize(memoryStream, instance.GameServers, new ListProxy <PhotonView> .Serializer <PhotonView>(PhotonViewProxy.Serialize));
                }
                else
                {
                    num |= 8;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsEnabled);
                BooleanProxy.Serialize(memoryStream, instance.WarnPlayer);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#10
0
        // Token: 0x06001062 RID: 4194 RVA: 0x00014394 File Offset: 0x00012594
        public static MemberView Deserialize(Stream bytes)
        {
            int        num        = Int32Proxy.Deserialize(bytes);
            MemberView memberView = new MemberView();

            if ((num & 1) != 0)
            {
                memberView.MemberItems = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                memberView.MemberWallet = MemberWalletViewProxy.Deserialize(bytes);
            }
            if ((num & 4) != 0)
            {
                memberView.PublicProfile = PublicProfileViewProxy.Deserialize(bytes);
            }
            return(memberView);
        }
        // Token: 0x0600110F RID: 4367 RVA: 0x0001AA74 File Offset: 0x00018C74
        public static void Serialize(Stream stream, CurrencyDepositsViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.CurrencyDeposits != null)
                {
                    ListProxy <CurrencyDepositView> .Serialize(memoryStream, instance.CurrencyDeposits, new ListProxy <CurrencyDepositView> .Serializer <CurrencyDepositView>(CurrencyDepositViewProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.TotalCount);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x0600110D RID: 4365 RVA: 0x0001A9AC File Offset: 0x00018BAC
        public static void Serialize(Stream stream, ItemTransactionsViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.ItemTransactions != null)
                {
                    ListProxy <ItemTransactionView> .Serialize(memoryStream, instance.ItemTransactions, new ListProxy <ItemTransactionView> .Serializer <ItemTransactionView>(ItemTransactionViewProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.TotalCount);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010FD RID: 4349 RVA: 0x00019BA0 File Offset: 0x00017DA0
        public static void Serialize(Stream stream, UberStrikeItemShopClientView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.FunctionalItems != null)
                {
                    ListProxy <UberStrikeItemFunctionalView> .Serialize(memoryStream, instance.FunctionalItems, new ListProxy <UberStrikeItemFunctionalView> .Serializer <UberStrikeItemFunctionalView>(UberStrikeItemFunctionalViewProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.GearItems != null)
                {
                    ListProxy <UberStrikeItemGearView> .Serialize(memoryStream, instance.GearItems, new ListProxy <UberStrikeItemGearView> .Serializer <UberStrikeItemGearView>(UberStrikeItemGearViewProxy.Serialize));
                }
                else
                {
                    num |= 2;
                }
                if (instance.QuickItems != null)
                {
                    ListProxy <UberStrikeItemQuickView> .Serialize(memoryStream, instance.QuickItems, new ListProxy <UberStrikeItemQuickView> .Serializer <UberStrikeItemQuickView>(UberStrikeItemQuickViewProxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                if (instance.WeaponItems != null)
                {
                    ListProxy <UberStrikeItemWeaponView> .Serialize(memoryStream, instance.WeaponItems, new ListProxy <UberStrikeItemWeaponView> .Serializer <UberStrikeItemWeaponView>(UberStrikeItemWeaponViewProxy.Serialize));
                }
                else
                {
                    num |= 8;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x06001111 RID: 4369 RVA: 0x0001AB3C File Offset: 0x00018D3C
        public static void Serialize(Stream stream, RegisterClientApplicationViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.ItemsAttributed != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.ItemsAttributed, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                EnumProxy <ApplicationRegistrationResult> .Serialize(memoryStream, instance.Result);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#15
0
        // Token: 0x060010E2 RID: 4322 RVA: 0x00018758 File Offset: 0x00016958
        public static MatchView Deserialize(Stream bytes)
        {
            int       num       = Int32Proxy.Deserialize(bytes);
            MatchView matchView = new MatchView();

            matchView.GameModeId = EnumProxy <GameModeType> .Deserialize(bytes);

            matchView.MapId = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                matchView.PlayersCompleted = ListProxy <PlayerStatisticsView> .Deserialize(bytes, new ListProxy <PlayerStatisticsView> .Deserializer <PlayerStatisticsView>(PlayerStatisticsViewProxy.Deserialize));
            }
            matchView.PlayersLimit = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                matchView.PlayersNonCompleted = ListProxy <PlayerStatisticsView> .Deserialize(bytes, new ListProxy <PlayerStatisticsView> .Deserializer <PlayerStatisticsView>(PlayerStatisticsViewProxy.Deserialize));
            }
            matchView.TimeLimit = Int32Proxy.Deserialize(bytes);
            return(matchView);
        }
示例#16
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);
        }
示例#17
0
        // Token: 0x06001058 RID: 4184 RVA: 0x00013C9C File Offset: 0x00011E9C
        public static LuckyDrawSetUnityView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            LuckyDrawSetUnityView luckyDrawSetUnityView = new LuckyDrawSetUnityView();

            luckyDrawSetUnityView.CreditsAttributed    = Int32Proxy.Deserialize(bytes);
            luckyDrawSetUnityView.ExposeItemsToPlayers = BooleanProxy.Deserialize(bytes);
            luckyDrawSetUnityView.Id = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                luckyDrawSetUnityView.ImageUrl = StringProxy.Deserialize(bytes);
            }
            luckyDrawSetUnityView.LuckyDrawId = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                luckyDrawSetUnityView.LuckyDrawSetItems = ListProxy <BundleItemView> .Deserialize(bytes, new ListProxy <BundleItemView> .Deserializer <BundleItemView>(BundleItemViewProxy.Deserialize));
            }
            luckyDrawSetUnityView.PointsAttributed = Int32Proxy.Deserialize(bytes);
            luckyDrawSetUnityView.SetWeight        = Int32Proxy.Deserialize(bytes);
            return(luckyDrawSetUnityView);
        }
        // Token: 0x06001032 RID: 4146 RVA: 0x0001205C File Offset: 0x0001025C
        public static ApplicationView Deserialize(Stream bytes)
        {
            int             num             = Int32Proxy.Deserialize(bytes);
            ApplicationView applicationView = new ApplicationView();

            applicationView.ApplicationVersionId = Int32Proxy.Deserialize(bytes);
            applicationView.Build = EnumProxy <BuildType> .Deserialize(bytes);

            applicationView.Channel = EnumProxy <ChannelType> .Deserialize(bytes);

            if ((num & 1) != 0)
            {
                applicationView.ExpirationDate = new DateTime?(DateTimeProxy.Deserialize(bytes));
            }
            if ((num & 2) != 0)
            {
                applicationView.FileName = StringProxy.Deserialize(bytes);
            }
            applicationView.IsCurrent     = BooleanProxy.Deserialize(bytes);
            applicationView.PhotonGroupId = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                applicationView.PhotonGroupName = StringProxy.Deserialize(bytes);
            }
            applicationView.ReleaseDate   = DateTimeProxy.Deserialize(bytes);
            applicationView.RemainingTime = Int32Proxy.Deserialize(bytes);
            if ((num & 8) != 0)
            {
                applicationView.Servers = ListProxy <PhotonView> .Deserialize(bytes, new ListProxy <PhotonView> .Deserializer <PhotonView>(PhotonViewProxy.Deserialize));
            }
            if ((num & 16) != 0)
            {
                applicationView.SupportUrl = StringProxy.Deserialize(bytes);
            }
            if ((num & 32) != 0)
            {
                applicationView.Version = StringProxy.Deserialize(bytes);
            }
            return(applicationView);
        }
示例#19
0
        // Token: 0x06001068 RID: 4200 RVA: 0x00014770 File Offset: 0x00012970
        public static MysteryBoxUnityView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            MysteryBoxUnityView mysteryBoxUnityView = new MysteryBoxUnityView();

            mysteryBoxUnityView.Category = EnumProxy <BundleCategoryType> .Deserialize(bytes);

            mysteryBoxUnityView.CreditsAttributed       = Int32Proxy.Deserialize(bytes);
            mysteryBoxUnityView.CreditsAttributedWeight = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                mysteryBoxUnityView.Description = StringProxy.Deserialize(bytes);
            }
            mysteryBoxUnityView.ExposeItemsToPlayers = BooleanProxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                mysteryBoxUnityView.IconUrl = StringProxy.Deserialize(bytes);
            }
            mysteryBoxUnityView.Id = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                mysteryBoxUnityView.ImageUrl = StringProxy.Deserialize(bytes);
            }
            mysteryBoxUnityView.IsAvailableInShop = BooleanProxy.Deserialize(bytes);
            mysteryBoxUnityView.ItemsAttributed   = Int32Proxy.Deserialize(bytes);
            if ((num & 8) != 0)
            {
                mysteryBoxUnityView.MysteryBoxItems = ListProxy <BundleItemView> .Deserialize(bytes, new ListProxy <BundleItemView> .Deserializer <BundleItemView>(BundleItemViewProxy.Deserialize));
            }
            if ((num & 16) != 0)
            {
                mysteryBoxUnityView.Name = StringProxy.Deserialize(bytes);
            }
            mysteryBoxUnityView.PointsAttributed       = Int32Proxy.Deserialize(bytes);
            mysteryBoxUnityView.PointsAttributedWeight = Int32Proxy.Deserialize(bytes);
            mysteryBoxUnityView.Price = Int32Proxy.Deserialize(bytes);
            mysteryBoxUnityView.UberStrikeCurrencyType = EnumProxy <UberStrikeCurrencyType> .Deserialize(bytes);

            return(mysteryBoxUnityView);
        }
示例#20
0
        // Token: 0x060010B7 RID: 4279 RVA: 0x000164AC File Offset: 0x000146AC
        public static void Serialize(Stream stream, MatchStats instance)
        {
            int num = 0;

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

                Int32Proxy.Serialize(memoryStream, instance.MapId);
                if (instance.Players != null)
                {
                    ListProxy <PlayerMatchStats> .Serialize(memoryStream, instance.Players, new ListProxy <PlayerMatchStats> .Serializer <PlayerMatchStats>(PlayerMatchStatsProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.PlayersLimit);
                Int32Proxy.Serialize(memoryStream, instance.TimeLimit);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010FE RID: 4350 RVA: 0x00019C98 File Offset: 0x00017E98
        public static UberStrikeItemShopClientView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            UberStrikeItemShopClientView uberStrikeItemShopClientView = new UberStrikeItemShopClientView();

            if ((num & 1) != 0)
            {
                uberStrikeItemShopClientView.FunctionalItems = ListProxy <UberStrikeItemFunctionalView> .Deserialize(bytes, new ListProxy <UberStrikeItemFunctionalView> .Deserializer <UberStrikeItemFunctionalView>(UberStrikeItemFunctionalViewProxy.Deserialize));
            }
            if ((num & 2) != 0)
            {
                uberStrikeItemShopClientView.GearItems = ListProxy <UberStrikeItemGearView> .Deserialize(bytes, new ListProxy <UberStrikeItemGearView> .Deserializer <UberStrikeItemGearView>(UberStrikeItemGearViewProxy.Deserialize));
            }
            if ((num & 4) != 0)
            {
                uberStrikeItemShopClientView.QuickItems = ListProxy <UberStrikeItemQuickView> .Deserialize(bytes, new ListProxy <UberStrikeItemQuickView> .Deserializer <UberStrikeItemQuickView>(UberStrikeItemQuickViewProxy.Deserialize));
            }
            if ((num & 8) != 0)
            {
                uberStrikeItemShopClientView.WeaponItems = ListProxy <UberStrikeItemWeaponView> .Deserialize(bytes, new ListProxy <UberStrikeItemWeaponView> .Deserializer <UberStrikeItemWeaponView>(UberStrikeItemWeaponViewProxy.Deserialize));
            }
            return(uberStrikeItemShopClientView);
        }
示例#22
0
        // Token: 0x06001039 RID: 4153 RVA: 0x000125A8 File Offset: 0x000107A8
        public static void Serialize(Stream stream, BundleView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.AndroidStoreUniqueId != null)
                {
                    StringProxy.Serialize(memoryStream, instance.AndroidStoreUniqueId);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.ApplicationId);
                if (instance.Availability != null)
                {
                    ListProxy <ChannelType> .Serialize(memoryStream, instance.Availability, new ListProxy <ChannelType> .Serializer <ChannelType>(EnumProxy <ChannelType> .Serialize));
                }
                else
                {
                    num |= 2;
                }
                if (instance.BundleItemViews != null)
                {
                    ListProxy <BundleItemView> .Serialize(memoryStream, instance.BundleItemViews, new ListProxy <BundleItemView> .Serializer <BundleItemView>(BundleItemViewProxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                EnumProxy <BundleCategoryType> .Serialize(memoryStream, instance.Category);

                Int32Proxy.Serialize(memoryStream, instance.Credits);
                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 8;
                }
                if (instance.IconUrl != null)
                {
                    StringProxy.Serialize(memoryStream, instance.IconUrl);
                }
                else
                {
                    num |= 16;
                }
                Int32Proxy.Serialize(memoryStream, instance.Id);
                if (instance.ImageUrl != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ImageUrl);
                }
                else
                {
                    num |= 32;
                }
                if (instance.IosAppStoreUniqueId != null)
                {
                    StringProxy.Serialize(memoryStream, instance.IosAppStoreUniqueId);
                }
                else
                {
                    num |= 64;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsDefault);
                BooleanProxy.Serialize(memoryStream, instance.IsOnSale);
                BooleanProxy.Serialize(memoryStream, instance.IsPromoted);
                if (instance.MacAppStoreUniqueId != null)
                {
                    StringProxy.Serialize(memoryStream, instance.MacAppStoreUniqueId);
                }
                else
                {
                    num |= 128;
                }
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 256;
                }
                Int32Proxy.Serialize(memoryStream, instance.Points);
                if (instance.PromotionTag != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PromotionTag);
                }
                else
                {
                    num |= 512;
                }
                DecimalProxy.Serialize(memoryStream, instance.USDPrice);
                DecimalProxy.Serialize(memoryStream, instance.USDPromoPrice);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010C1 RID: 4289 RVA: 0x00016B78 File Offset: 0x00014D78
        public static void Serialize(Stream stream, GameActorInfo instance)
        {
            int num = 0;

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

                ByteProxy.Serialize(memoryStream, instance.ArmorPointCapacity);
                ByteProxy.Serialize(memoryStream, instance.ArmorPoints);
                EnumProxy <ChannelType> .Serialize(memoryStream, instance.Channel);

                if (instance.ClanTag != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ClanTag);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                EnumProxy <FireMode> .Serialize(memoryStream, instance.CurrentFiringMode);

                ByteProxy.Serialize(memoryStream, instance.CurrentWeaponSlot);
                Int16Proxy.Serialize(memoryStream, instance.Deaths);
                if (instance.FunctionalItems != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.FunctionalItems, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 2;
                }
                if (instance.Gear != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.Gear, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                Int16Proxy.Serialize(memoryStream, instance.Health);
                Int16Proxy.Serialize(memoryStream, instance.Kills);
                Int32Proxy.Serialize(memoryStream, instance.Level);
                UInt16Proxy.Serialize(memoryStream, instance.Ping);
                ByteProxy.Serialize(memoryStream, instance.PlayerId);
                if (instance.PlayerName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PlayerName);
                }
                else
                {
                    num |= 8;
                }
                EnumProxy <PlayerStates> .Serialize(memoryStream, instance.PlayerState);

                if (instance.QuickItems != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.QuickItems, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 16;
                }
                ByteProxy.Serialize(memoryStream, instance.Rank);
                ColorProxy.Serialize(memoryStream, instance.SkinColor);
                EnumProxy <SurfaceType> .Serialize(memoryStream, instance.StepSound);

                EnumProxy <TeamID> .Serialize(memoryStream, instance.TeamID);

                if (instance.Weapons != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.Weapons, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 32;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#24
0
        // Token: 0x06001047 RID: 4167 RVA: 0x00012DF0 File Offset: 0x00010FF0
        public static void Serialize(Stream stream, ClanView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Address != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Address);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.ApplicationId);
                EnumProxy <GroupColor> .Serialize(memoryStream, instance.ColorStyle);

                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 2;
                }
                EnumProxy <GroupFontStyle> .Serialize(memoryStream, instance.FontStyle);

                DateTimeProxy.Serialize(memoryStream, instance.FoundingDate);
                Int32Proxy.Serialize(memoryStream, instance.GroupId);
                DateTimeProxy.Serialize(memoryStream, instance.LastUpdated);
                if (instance.Members != null)
                {
                    ListProxy <ClanMemberView> .Serialize(memoryStream, instance.Members, new ListProxy <ClanMemberView> .Serializer <ClanMemberView>(ClanMemberViewProxy.Serialize));
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(memoryStream, instance.MembersCount);
                Int32Proxy.Serialize(memoryStream, instance.MembersLimit);
                if (instance.Motto != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Motto);
                }
                else
                {
                    num |= 8;
                }
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 16;
                }
                Int32Proxy.Serialize(memoryStream, instance.OwnerCmid);
                if (instance.OwnerName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.OwnerName);
                }
                else
                {
                    num |= 32;
                }
                if (instance.Picture != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Picture);
                }
                else
                {
                    num |= 64;
                }
                if (instance.Tag != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Tag);
                }
                else
                {
                    num |= 128;
                }
                EnumProxy <GroupType> .Serialize(memoryStream, instance.Type);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#25
0
        // Token: 0x060010B6 RID: 4278 RVA: 0x0001612C File Offset: 0x0001432C
        public static GameActorInfoDelta Deserialize(Stream bytes)
        {
            int  num = Int32Proxy.Deserialize(bytes);
            byte id  = ByteProxy.Deserialize(bytes);
            GameActorInfoDelta gameActorInfoDelta = new GameActorInfoDelta();

            gameActorInfoDelta.Id = id;
            if (num != 0)
            {
                if ((num & 1) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.AccessLevel] = EnumProxy <MemberAccessLevel> .Deserialize(bytes);
                }
                if ((num & 2) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.ArmorPointCapacity] = ByteProxy.Deserialize(bytes);
                }
                if ((num & 4) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.ArmorPoints] = ByteProxy.Deserialize(bytes);
                }
                if ((num & 8) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Channel] = EnumProxy <ChannelType> .Deserialize(bytes);
                }
                if ((num & 16) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.ClanTag] = StringProxy.Deserialize(bytes);
                }
                if ((num & 32) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Cmid] = Int32Proxy.Deserialize(bytes);
                }
                if ((num & 64) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.CurrentFiringMode] = EnumProxy <FireMode> .Deserialize(bytes);
                }
                if ((num & 128) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.CurrentWeaponSlot] = ByteProxy.Deserialize(bytes);
                }
                if ((num & 256) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Deaths] = Int16Proxy.Deserialize(bytes);
                }
                if ((num & 512) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.FunctionalItems] = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
                }
                if ((num & 1024) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Gear] = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
                }
                if ((num & 2048) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Health] = Int16Proxy.Deserialize(bytes);
                }
                if ((num & 4096) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Kills] = Int16Proxy.Deserialize(bytes);
                }
                if ((num & 8192) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Level] = Int32Proxy.Deserialize(bytes);
                }
                if ((num & 16384) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Ping] = UInt16Proxy.Deserialize(bytes);
                }
                if ((num & 32768) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.PlayerId] = ByteProxy.Deserialize(bytes);
                }
                if ((num & 65536) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.PlayerName] = StringProxy.Deserialize(bytes);
                }
                if ((num & 131072) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.PlayerState] = EnumProxy <PlayerStates> .Deserialize(bytes);
                }
                if ((num & 262144) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.QuickItems] = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
                }
                if ((num & 524288) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Rank] = ByteProxy.Deserialize(bytes);
                }
                if ((num & 1048576) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.SkinColor] = ColorProxy.Deserialize(bytes);
                }
                if ((num & 2097152) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.StepSound] = EnumProxy <SurfaceType> .Deserialize(bytes);
                }
                if ((num & 4194304) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.TeamID] = EnumProxy <TeamID> .Deserialize(bytes);
                }
                if ((num & 8388608) != 0)
                {
                    gameActorInfoDelta.Changes[GameActorInfoDelta.Keys.Weapons] = ListProxy <int> .Deserialize(bytes, new ListProxy <int> .Deserializer <int>(Int32Proxy.Deserialize));
                }
            }
            return(gameActorInfoDelta);
        }
示例#26
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);
            }
        }
示例#27
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);
        }
        // Token: 0x06001031 RID: 4145 RVA: 0x00011EBC File Offset: 0x000100BC
        public static void Serialize(Stream stream, ApplicationView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.ApplicationVersionId);
                EnumProxy <BuildType> .Serialize(memoryStream, instance.Build);

                EnumProxy <ChannelType> .Serialize(memoryStream, instance.Channel);

                if (instance.ExpirationDate != null)
                {
                    Stream   bytes          = memoryStream;
                    DateTime?expirationDate = instance.ExpirationDate;
                    DateTimeProxy.Serialize(bytes, (expirationDate == null) ? default(DateTime) : expirationDate.Value);
                }
                else
                {
                    num |= 1;
                }
                if (instance.FileName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.FileName);
                }
                else
                {
                    num |= 2;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsCurrent);
                Int32Proxy.Serialize(memoryStream, instance.PhotonGroupId);
                if (instance.PhotonGroupName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PhotonGroupName);
                }
                else
                {
                    num |= 4;
                }
                DateTimeProxy.Serialize(memoryStream, instance.ReleaseDate);
                Int32Proxy.Serialize(memoryStream, instance.RemainingTime);
                if (instance.Servers != null)
                {
                    ListProxy <PhotonView> .Serialize(memoryStream, instance.Servers, new ListProxy <PhotonView> .Serializer <PhotonView>(PhotonViewProxy.Serialize));
                }
                else
                {
                    num |= 8;
                }
                if (instance.SupportUrl != null)
                {
                    StringProxy.Serialize(memoryStream, instance.SupportUrl);
                }
                else
                {
                    num |= 16;
                }
                if (instance.Version != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Version);
                }
                else
                {
                    num |= 32;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
示例#29
0
 // Token: 0x060010B5 RID: 4277 RVA: 0x00015D0C File Offset: 0x00013F0C
 public static void Serialize(Stream stream, GameActorInfoDelta instance)
 {
     if (instance != null)
     {
         Int32Proxy.Serialize(stream, instance.DeltaMask);
         ByteProxy.Serialize(stream, instance.Id);
         if ((instance.DeltaMask & 1) != 0)
         {
             EnumProxy <MemberAccessLevel> .Serialize(stream, (MemberAccessLevel)((int)instance.Changes[GameActorInfoDelta.Keys.AccessLevel]));
         }
         if ((instance.DeltaMask & 2) != 0)
         {
             ByteProxy.Serialize(stream, (byte)instance.Changes[GameActorInfoDelta.Keys.ArmorPointCapacity]);
         }
         if ((instance.DeltaMask & 4) != 0)
         {
             ByteProxy.Serialize(stream, (byte)instance.Changes[GameActorInfoDelta.Keys.ArmorPoints]);
         }
         if ((instance.DeltaMask & 8) != 0)
         {
             EnumProxy <ChannelType> .Serialize(stream, (ChannelType)((int)instance.Changes[GameActorInfoDelta.Keys.Channel]));
         }
         if ((instance.DeltaMask & 16) != 0)
         {
             StringProxy.Serialize(stream, (string)instance.Changes[GameActorInfoDelta.Keys.ClanTag]);
         }
         if ((instance.DeltaMask & 32) != 0)
         {
             Int32Proxy.Serialize(stream, (int)instance.Changes[GameActorInfoDelta.Keys.Cmid]);
         }
         if ((instance.DeltaMask & 64) != 0)
         {
             EnumProxy <FireMode> .Serialize(stream, (FireMode)((int)instance.Changes[GameActorInfoDelta.Keys.CurrentFiringMode]));
         }
         if ((instance.DeltaMask & 128) != 0)
         {
             ByteProxy.Serialize(stream, (byte)instance.Changes[GameActorInfoDelta.Keys.CurrentWeaponSlot]);
         }
         if ((instance.DeltaMask & 256) != 0)
         {
             Int16Proxy.Serialize(stream, (short)instance.Changes[GameActorInfoDelta.Keys.Deaths]);
         }
         if ((instance.DeltaMask & 512) != 0)
         {
             ListProxy <int> .Serialize(stream, (List <int>) instance.Changes[GameActorInfoDelta.Keys.FunctionalItems], new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
         }
         if ((instance.DeltaMask & 1024) != 0)
         {
             ListProxy <int> .Serialize(stream, (List <int>) instance.Changes[GameActorInfoDelta.Keys.Gear], new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
         }
         if ((instance.DeltaMask & 2048) != 0)
         {
             Int16Proxy.Serialize(stream, (short)instance.Changes[GameActorInfoDelta.Keys.Health]);
         }
         if ((instance.DeltaMask & 4096) != 0)
         {
             Int16Proxy.Serialize(stream, (short)instance.Changes[GameActorInfoDelta.Keys.Kills]);
         }
         if ((instance.DeltaMask & 8192) != 0)
         {
             Int32Proxy.Serialize(stream, (int)instance.Changes[GameActorInfoDelta.Keys.Level]);
         }
         if ((instance.DeltaMask & 16384) != 0)
         {
             UInt16Proxy.Serialize(stream, (ushort)instance.Changes[GameActorInfoDelta.Keys.Ping]);
         }
         if ((instance.DeltaMask & 32768) != 0)
         {
             ByteProxy.Serialize(stream, (byte)instance.Changes[GameActorInfoDelta.Keys.PlayerId]);
         }
         if ((instance.DeltaMask & 65536) != 0)
         {
             StringProxy.Serialize(stream, (string)instance.Changes[GameActorInfoDelta.Keys.PlayerName]);
         }
         if ((instance.DeltaMask & 131072) != 0)
         {
             EnumProxy <PlayerStates> .Serialize(stream, (PlayerStates)((byte)instance.Changes[GameActorInfoDelta.Keys.PlayerState]));
         }
         if ((instance.DeltaMask & 262144) != 0)
         {
             ListProxy <int> .Serialize(stream, (List <int>) instance.Changes[GameActorInfoDelta.Keys.QuickItems], new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
         }
         if ((instance.DeltaMask & 524288) != 0)
         {
             ByteProxy.Serialize(stream, (byte)instance.Changes[GameActorInfoDelta.Keys.Rank]);
         }
         if ((instance.DeltaMask & 1048576) != 0)
         {
             ColorProxy.Serialize(stream, (Color)instance.Changes[GameActorInfoDelta.Keys.SkinColor]);
         }
         if ((instance.DeltaMask & 2097152) != 0)
         {
             EnumProxy <SurfaceType> .Serialize(stream, (SurfaceType)((int)instance.Changes[GameActorInfoDelta.Keys.StepSound]));
         }
         if ((instance.DeltaMask & 4194304) != 0)
         {
             EnumProxy <TeamID> .Serialize(stream, (TeamID)((int)instance.Changes[GameActorInfoDelta.Keys.TeamID]));
         }
         if ((instance.DeltaMask & 8388608) != 0)
         {
             ListProxy <int> .Serialize(stream, (List <int>) instance.Changes[GameActorInfoDelta.Keys.Weapons], new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
         }
     }
     else
     {
         Int32Proxy.Serialize(stream, 0);
     }
 }
示例#30
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);
            }
        }