Beispiel #1
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 #2
0
        // Token: 0x060010E1 RID: 4321 RVA: 0x00018688 File Offset: 0x00016888
        public static void Serialize(Stream stream, MatchView instance)
        {
            int num = 0;

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

                Int32Proxy.Serialize(memoryStream, instance.MapId);
                if (instance.PlayersCompleted != null)
                {
                    ListProxy <PlayerStatisticsView> .Serialize(memoryStream, instance.PlayersCompleted, new ListProxy <PlayerStatisticsView> .Serializer <PlayerStatisticsView>(PlayerStatisticsViewProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.PlayersLimit);
                if (instance.PlayersNonCompleted != null)
                {
                    ListProxy <PlayerStatisticsView> .Serialize(memoryStream, instance.PlayersNonCompleted, new ListProxy <PlayerStatisticsView> .Serializer <PlayerStatisticsView>(PlayerStatisticsViewProxy.Serialize));
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.TimeLimit);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #3
0
        // Token: 0x0600106F RID: 4207 RVA: 0x00014ADC File Offset: 0x00012CDC
        public static void Serialize(Stream stream, PhotonView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.IP != null)
                {
                    StringProxy.Serialize(memoryStream, instance.IP);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.MinLatency);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.PhotonId);
                Int32Proxy.Serialize(memoryStream, instance.Port);
                EnumProxy <RegionType> .Serialize(memoryStream, instance.Region);

                EnumProxy <PhotonUsageType> .Serialize(memoryStream, instance.UsageType);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #4
0
        // Token: 0x0600104B RID: 4171 RVA: 0x00013214 File Offset: 0x00011414
        public static void Serialize(Stream stream, ContactRequestView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.InitiatorCmid);
                if (instance.InitiatorMessage != null)
                {
                    StringProxy.Serialize(memoryStream, instance.InitiatorMessage);
                }
                else
                {
                    num |= 1;
                }
                if (instance.InitiatorName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.InitiatorName);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.ReceiverCmid);
                Int32Proxy.Serialize(memoryStream, instance.RequestId);
                DateTimeProxy.Serialize(memoryStream, instance.SentDate);
                EnumProxy <ContactRequestStatus> .Serialize(memoryStream, instance.Status);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #5
0
        // Token: 0x0600104D RID: 4173 RVA: 0x00013358 File Offset: 0x00011558
        public static void Serialize(Stream stream, CurrencyDepositView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.ApplicationId);
                if (instance.BundleId != null)
                {
                    Stream bytes    = memoryStream;
                    int?   bundleId = instance.BundleId;
                    Int32Proxy.Serialize(bytes, (bundleId == null) ? 0 : bundleId.Value);
                }
                else
                {
                    num |= 1;
                }
                if (instance.BundleName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.BundleName);
                }
                else
                {
                    num |= 2;
                }
                DecimalProxy.Serialize(memoryStream, instance.Cash);
                EnumProxy <ChannelType> .Serialize(memoryStream, instance.ChannelId);

                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                Int32Proxy.Serialize(memoryStream, instance.Credits);
                Int32Proxy.Serialize(memoryStream, instance.CreditsDepositId);
                if (instance.CurrencyLabel != null)
                {
                    StringProxy.Serialize(memoryStream, instance.CurrencyLabel);
                }
                else
                {
                    num |= 4;
                }
                DateTimeProxy.Serialize(memoryStream, instance.DepositDate);
                BooleanProxy.Serialize(memoryStream, instance.IsAdminAction);
                EnumProxy <PaymentProviderType> .Serialize(memoryStream, instance.PaymentProviderId);

                Int32Proxy.Serialize(memoryStream, instance.Points);
                if (instance.TransactionKey != null)
                {
                    StringProxy.Serialize(memoryStream, instance.TransactionKey);
                }
                else
                {
                    num |= 8;
                }
                DecimalProxy.Serialize(memoryStream, instance.UsdAmount);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x06001037 RID: 4151 RVA: 0x000124F8 File Offset: 0x000106F8
        public static void Serialize(Stream stream, BundleItemView instance)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.Amount);
                Int32Proxy.Serialize(memoryStream, instance.BundleId);
                EnumProxy <BuyingDurationType> .Serialize(memoryStream, instance.Duration);

                Int32Proxy.Serialize(memoryStream, instance.ItemId);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #7
0
        // Token: 0x06001071 RID: 4209 RVA: 0x00014C20 File Offset: 0x00012E20
        public static void Serialize(Stream stream, PointDepositView instance)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                DateTimeProxy.Serialize(memoryStream, instance.DepositDate);
                EnumProxy <PointsDepositType> .Serialize(memoryStream, instance.DepositType);

                BooleanProxy.Serialize(memoryStream, instance.IsAdminAction);
                Int32Proxy.Serialize(memoryStream, instance.PointDepositId);
                Int32Proxy.Serialize(memoryStream, instance.Points);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #8
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);
            }
        }
Beispiel #9
0
        // Token: 0x060010DF RID: 4319 RVA: 0x00018314 File Offset: 0x00016514
        public static void Serialize(Stream stream, LoadoutView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.Backpack);
                Int32Proxy.Serialize(memoryStream, instance.Boots);
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                Int32Proxy.Serialize(memoryStream, instance.Face);
                Int32Proxy.Serialize(memoryStream, instance.FunctionalItem1);
                Int32Proxy.Serialize(memoryStream, instance.FunctionalItem2);
                Int32Proxy.Serialize(memoryStream, instance.FunctionalItem3);
                Int32Proxy.Serialize(memoryStream, instance.Gloves);
                Int32Proxy.Serialize(memoryStream, instance.Head);
                Int32Proxy.Serialize(memoryStream, instance.LoadoutId);
                Int32Proxy.Serialize(memoryStream, instance.LowerBody);
                Int32Proxy.Serialize(memoryStream, instance.MeleeWeapon);
                Int32Proxy.Serialize(memoryStream, instance.QuickItem1);
                Int32Proxy.Serialize(memoryStream, instance.QuickItem2);
                Int32Proxy.Serialize(memoryStream, instance.QuickItem3);
                if (instance.SkinColor != null)
                {
                    StringProxy.Serialize(memoryStream, instance.SkinColor);
                }
                else
                {
                    num |= 1;
                }
                EnumProxy <AvatarType> .Serialize(memoryStream, instance.Type);

                Int32Proxy.Serialize(memoryStream, instance.UpperBody);
                Int32Proxy.Serialize(memoryStream, instance.Weapon1);
                Int32Proxy.Serialize(memoryStream, instance.Weapon1Mod1);
                Int32Proxy.Serialize(memoryStream, instance.Weapon1Mod2);
                Int32Proxy.Serialize(memoryStream, instance.Weapon1Mod3);
                Int32Proxy.Serialize(memoryStream, instance.Weapon2);
                Int32Proxy.Serialize(memoryStream, instance.Weapon2Mod1);
                Int32Proxy.Serialize(memoryStream, instance.Weapon2Mod2);
                Int32Proxy.Serialize(memoryStream, instance.Weapon2Mod3);
                Int32Proxy.Serialize(memoryStream, instance.Weapon3);
                Int32Proxy.Serialize(memoryStream, instance.Weapon3Mod1);
                Int32Proxy.Serialize(memoryStream, instance.Weapon3Mod2);
                Int32Proxy.Serialize(memoryStream, instance.Weapon3Mod3);
                Int32Proxy.Serialize(memoryStream, instance.Webbing);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
 // Token: 0x06001055 RID: 4181 RVA: 0x00013AB0 File Offset: 0x00011CB0
 public static void Serialize(Stream stream, ItemTransactionView instance)
 {
     using (MemoryStream memoryStream = new MemoryStream())
     {
         Int32Proxy.Serialize(memoryStream, instance.Cmid);
         Int32Proxy.Serialize(memoryStream, instance.Credits);
         EnumProxy<BuyingDurationType>.Serialize(memoryStream, instance.Duration);
         BooleanProxy.Serialize(memoryStream, instance.IsAdminAction);
         Int32Proxy.Serialize(memoryStream, instance.ItemId);
         Int32Proxy.Serialize(memoryStream, instance.Points);
         DateTimeProxy.Serialize(memoryStream, instance.WithdrawalDate);
         Int32Proxy.Serialize(memoryStream, instance.WithdrawalId);
         memoryStream.WriteTo(stream);
     }
 }
        // Token: 0x060010C7 RID: 4295 RVA: 0x000170F4 File Offset: 0x000152F4
        public static void Serialize(Stream stream, CommActorInfo instance)
        {
            int num = 0;

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

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

                if (instance.ClanTag != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ClanTag);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                if (instance.CurrentRoom != null)
                {
                    GameRoomProxy.Serialize(memoryStream, instance.CurrentRoom);
                }
                else
                {
                    num |= 2;
                }
                ByteProxy.Serialize(memoryStream, instance.ModerationFlag);
                if (instance.ModInformation != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ModInformation);
                }
                else
                {
                    num |= 4;
                }
                if (instance.PlayerName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.PlayerName);
                }
                else
                {
                    num |= 8;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010DB RID: 4315 RVA: 0x000180F0 File Offset: 0x000162F0
        public static void Serialize(Stream stream, ItemQuickUseConfigView instance)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                EnumProxy <QuickItemLogic> .Serialize(memoryStream, instance.BehaviourType);

                Int32Proxy.Serialize(memoryStream, instance.CoolDownTime);
                Int32Proxy.Serialize(memoryStream, instance.ItemId);
                Int32Proxy.Serialize(memoryStream, instance.LevelRequired);
                Int32Proxy.Serialize(memoryStream, instance.UsesPerGame);
                Int32Proxy.Serialize(memoryStream, instance.UsesPerLife);
                Int32Proxy.Serialize(memoryStream, instance.UsesPerRound);
                Int32Proxy.Serialize(memoryStream, instance.WarmUpTime);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010F3 RID: 4339 RVA: 0x000192C0 File Offset: 0x000174C0
        public static void Serialize(Stream stream, ItemPrice instance)
        {
            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.Amount);
                EnumProxy <UberStrikeCurrencyType> .Serialize(memoryStream, instance.Currency);

                Int32Proxy.Serialize(memoryStream, instance.Discount);
                EnumProxy <BuyingDurationType> .Serialize(memoryStream, instance.Duration);

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

                Int32Proxy.Serialize(memoryStream, instance.Price);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010CB RID: 4299 RVA: 0x00017308 File Offset: 0x00015508
        public static void Serialize(Stream stream, GameRoomData instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.ConnectedPlayers);
                Int32Proxy.Serialize(memoryStream, instance.GameFlags);
                EnumProxy <GameModeType> .Serialize(memoryStream, instance.GameMode);

                if (instance.Guid != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Guid);
                }
                else
                {
                    num |= 1;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsPasswordProtected);
                BooleanProxy.Serialize(memoryStream, instance.IsPermanentGame);
                Int32Proxy.Serialize(memoryStream, instance.KillLimit);
                ByteProxy.Serialize(memoryStream, instance.LevelMax);
                ByteProxy.Serialize(memoryStream, instance.LevelMin);
                Int32Proxy.Serialize(memoryStream, instance.MapID);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.Number);
                Int32Proxy.Serialize(memoryStream, instance.PlayerLimit);
                if (instance.Server != null)
                {
                    ConnectionAddressProxy.Serialize(memoryStream, instance.Server);
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(memoryStream, instance.TimeLimit);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #15
0
        // Token: 0x06001105 RID: 4357 RVA: 0x0001A5BC File Offset: 0x000187BC
        public static void Serialize(Stream stream, MemberAuthenticationResultView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.AuthToken != null)
                {
                    StringProxy.Serialize(memoryStream, instance.AuthToken);
                }
                else
                {
                    num |= 1;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsAccountComplete);
                if (instance.LuckyDraw != null)
                {
                    LuckyDrawUnityViewProxy.Serialize(memoryStream, instance.LuckyDraw);
                }
                else
                {
                    num |= 2;
                }
                EnumProxy <MemberAuthenticationResult> .Serialize(memoryStream, instance.MemberAuthenticationResult);

                if (instance.MemberView != null)
                {
                    MemberViewProxy.Serialize(memoryStream, instance.MemberView);
                }
                else
                {
                    num |= 4;
                }
                if (instance.PlayerStatisticsView != null)
                {
                    PlayerStatisticsViewProxy.Serialize(memoryStream, instance.PlayerStatisticsView);
                }
                else
                {
                    num |= 8;
                }
                DateTimeProxy.Serialize(memoryStream, instance.ServerTime);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #16
0
 // Token: 0x060010AD RID: 4269 RVA: 0x00015794 File Offset: 0x00013994
 public static void Serialize(Stream stream, CommActorInfoDelta 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[CommActorInfoDelta.Keys.AccessLevel]));
         }
         if ((instance.DeltaMask & 2) != 0)
         {
             EnumProxy <ChannelType> .Serialize(stream, (ChannelType)((int)instance.Changes[CommActorInfoDelta.Keys.Channel]));
         }
         if ((instance.DeltaMask & 4) != 0)
         {
             StringProxy.Serialize(stream, (string)instance.Changes[CommActorInfoDelta.Keys.ClanTag]);
         }
         if ((instance.DeltaMask & 8) != 0)
         {
             Int32Proxy.Serialize(stream, (int)instance.Changes[CommActorInfoDelta.Keys.Cmid]);
         }
         if ((instance.DeltaMask & 16) != 0)
         {
             GameRoomProxy.Serialize(stream, (GameRoom)instance.Changes[CommActorInfoDelta.Keys.CurrentRoom]);
         }
         if ((instance.DeltaMask & 32) != 0)
         {
             ByteProxy.Serialize(stream, (byte)instance.Changes[CommActorInfoDelta.Keys.ModerationFlag]);
         }
         if ((instance.DeltaMask & 64) != 0)
         {
             StringProxy.Serialize(stream, (string)instance.Changes[CommActorInfoDelta.Keys.ModInformation]);
         }
         if ((instance.DeltaMask & 128) != 0)
         {
             StringProxy.Serialize(stream, (string)instance.Changes[CommActorInfoDelta.Keys.PlayerName]);
         }
     }
     else
     {
         Int32Proxy.Serialize(stream, 0);
     }
 }
        // Token: 0x0600105F RID: 4191 RVA: 0x00014138 File Offset: 0x00012338
        public static void Serialize(Stream stream, MemberSessionDataView instance)
        {
            int num = 0;

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

                if (instance.AuthToken != null)
                {
                    StringProxy.Serialize(memoryStream, instance.AuthToken);
                }
                else
                {
                    num |= 1;
                }
                EnumProxy <ChannelType> .Serialize(memoryStream, instance.Channel);

                if (instance.ClanTag != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ClanTag);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                BooleanProxy.Serialize(memoryStream, instance.IsBanned);
                Int32Proxy.Serialize(memoryStream, instance.Level);
                DateTimeProxy.Serialize(memoryStream, instance.LoginDate);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(memoryStream, instance.XP);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x06001107 RID: 4359 RVA: 0x0001A738 File Offset: 0x00018938
        public static void Serialize(Stream stream, MemberAuthenticationViewModel instance)
        {
            int num = 0;

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

                if (instance.MemberView != null)
                {
                    MemberViewProxy.Serialize(memoryStream, instance.MemberView);
                }
                else
                {
                    num |= 1;
                }
                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);
            }
        }
        // Token: 0x06001075 RID: 4213 RVA: 0x00014E8C File Offset: 0x0001308C
        public static void Serialize(Stream stream, PublicProfileView instance)
        {
            int num = 0;

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

                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                EnumProxy <EmailAddressStatus> .Serialize(memoryStream, instance.EmailAddressStatus);

                if (instance.FacebookId != null)
                {
                    StringProxy.Serialize(memoryStream, instance.FacebookId);
                }
                else
                {
                    num |= 1;
                }
                if (instance.GroupTag != null)
                {
                    StringProxy.Serialize(memoryStream, instance.GroupTag);
                }
                else
                {
                    num |= 2;
                }
                BooleanProxy.Serialize(memoryStream, instance.IsChatDisabled);
                DateTimeProxy.Serialize(memoryStream, instance.LastLoginDate);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #21
0
        // Token: 0x0600105B RID: 4187 RVA: 0x00013EF8 File Offset: 0x000120F8
        public static void Serialize(Stream stream, MemberPositionUpdateView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.AuthToken != null)
                {
                    StringProxy.Serialize(memoryStream, instance.AuthToken);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.GroupId);
                Int32Proxy.Serialize(memoryStream, instance.MemberCmid);
                EnumProxy <GroupPosition> .Serialize(memoryStream, instance.Position);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #22
0
        // Token: 0x0600105D RID: 4189 RVA: 0x00013FD8 File Offset: 0x000121D8
        public static void Serialize(Stream stream, MemberReportView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.ApplicationId);
                if (instance.Context != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Context);
                }
                else
                {
                    num |= 1;
                }
                if (instance.IP != null)
                {
                    StringProxy.Serialize(memoryStream, instance.IP);
                }
                else
                {
                    num |= 2;
                }
                if (instance.Reason != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Reason);
                }
                else
                {
                    num |= 4;
                }
                EnumProxy <MemberReportType> .Serialize(memoryStream, instance.ReportType);

                Int32Proxy.Serialize(memoryStream, instance.SourceCmid);
                Int32Proxy.Serialize(memoryStream, instance.TargetCmid);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x0600103D RID: 4157 RVA: 0x00012A2C File Offset: 0x00010C2C
        public static void Serialize(Stream stream, ClaimFacebookGiftView instance)
        {
            int num = 0;

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

                if (instance.ItemId != null)
                {
                    Stream bytes  = memoryStream;
                    int?   itemId = instance.ItemId;
                    Int32Proxy.Serialize(bytes, (itemId == null) ? 0 : itemId.Value);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x06001041 RID: 4161 RVA: 0x00012BB0 File Offset: 0x00010DB0
        public static void Serialize(Stream stream, ClanMemberView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                DateTimeProxy.Serialize(memoryStream, instance.JoiningDate);
                DateTimeProxy.Serialize(memoryStream, instance.Lastlogin);
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 1;
                }
                EnumProxy <GroupPosition> .Serialize(memoryStream, instance.Position);

                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010BB RID: 4283 RVA: 0x00016790 File Offset: 0x00014990
        public static void Serialize(Stream stream, ServerConnectionView instance)
        {
            int num = 0;

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

                if (instance.ApiVersion != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ApiVersion);
                }
                else
                {
                    num |= 1;
                }
                EnumProxy <ChannelType> .Serialize(memoryStream, instance.Channel);

                Int32Proxy.Serialize(memoryStream, instance.Cmid);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #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);
            }
        }
Beispiel #27
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);
     }
 }
        // 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);
            }
        }
Beispiel #29
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);
            }
        }
Beispiel #30
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);
            }
        }