Beispiel #1
0
        // Token: 0x06001106 RID: 4358 RVA: 0x0001A6A8 File Offset: 0x000188A8
        public static MemberAuthenticationResultView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            MemberAuthenticationResultView memberAuthenticationResultView = new MemberAuthenticationResultView();

            if ((num & 1) != 0)
            {
                memberAuthenticationResultView.AuthToken = StringProxy.Deserialize(bytes);
            }
            memberAuthenticationResultView.IsAccountComplete = BooleanProxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                memberAuthenticationResultView.LuckyDraw = LuckyDrawUnityViewProxy.Deserialize(bytes);
            }
            memberAuthenticationResultView.MemberAuthenticationResult = EnumProxy <MemberAuthenticationResult> .Deserialize(bytes);

            if ((num & 4) != 0)
            {
                memberAuthenticationResultView.MemberView = MemberViewProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                memberAuthenticationResultView.PlayerStatisticsView = PlayerStatisticsViewProxy.Deserialize(bytes);
            }
            memberAuthenticationResultView.ServerTime = DateTimeProxy.Deserialize(bytes);
            return(memberAuthenticationResultView);
        }
Beispiel #2
0
        // Token: 0x06001035 RID: 4149 RVA: 0x0001242C File Offset: 0x0001062C
        public static void Serialize(Stream stream, BugView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Content != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Content);
                }
                else
                {
                    num |= 1;
                }
                if (instance.Subject != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Subject);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #3
0
        // Token: 0x06001102 RID: 4354 RVA: 0x0001A324 File Offset: 0x00018524
        public static GameApplicationView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            GameApplicationView gameApplicationView = new GameApplicationView();

            if ((num & 1) != 0)
            {
                gameApplicationView.CommServer = PhotonViewProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                gameApplicationView.EncryptionInitVector = StringProxy.Deserialize(bytes);
            }
            if ((num & 4) != 0)
            {
                gameApplicationView.EncryptionPassPhrase = StringProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                gameApplicationView.GameServers = ListProxy <PhotonView> .Deserialize(bytes, new ListProxy <PhotonView> .Deserializer <PhotonView>(PhotonViewProxy.Deserialize));
            }
            if ((num & 16) != 0)
            {
                gameApplicationView.SupportUrl = StringProxy.Deserialize(bytes);
            }
            if ((num & 32) != 0)
            {
                gameApplicationView.Version = StringProxy.Deserialize(bytes);
            }
            return(gameApplicationView);
        }
        // Token: 0x06001076 RID: 4214 RVA: 0x00014F70 File Offset: 0x00013170
        public static PublicProfileView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            PublicProfileView publicProfileView = new PublicProfileView();

            publicProfileView.AccessLevel = EnumProxy <MemberAccessLevel> .Deserialize(bytes);

            publicProfileView.Cmid = Int32Proxy.Deserialize(bytes);
            publicProfileView.EmailAddressStatus = EnumProxy <EmailAddressStatus> .Deserialize(bytes);

            if ((num & 1) != 0)
            {
                publicProfileView.FacebookId = StringProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                publicProfileView.GroupTag = StringProxy.Deserialize(bytes);
            }
            publicProfileView.IsChatDisabled = BooleanProxy.Deserialize(bytes);
            publicProfileView.LastLoginDate  = DateTimeProxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                publicProfileView.Name = StringProxy.Deserialize(bytes);
            }
            return(publicProfileView);
        }
        // Token: 0x06001073 RID: 4211 RVA: 0x00014D00 File Offset: 0x00012F00
        public static void Serialize(Stream stream, PrivateMessageView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.ContentText != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ContentText);
                }
                else
                {
                    num |= 1;
                }
                DateTimeProxy.Serialize(memoryStream, instance.DateSent);
                Int32Proxy.Serialize(memoryStream, instance.FromCmid);
                if (instance.FromName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.FromName);
                }
                else
                {
                    num |= 2;
                }
                BooleanProxy.Serialize(memoryStream, instance.HasAttachment);
                BooleanProxy.Serialize(memoryStream, instance.IsDeletedByReceiver);
                BooleanProxy.Serialize(memoryStream, instance.IsDeletedBySender);
                BooleanProxy.Serialize(memoryStream, instance.IsRead);
                Int32Proxy.Serialize(memoryStream, instance.PrivateMessageId);
                Int32Proxy.Serialize(memoryStream, instance.ToCmid);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010BA RID: 4282 RVA: 0x000166C8 File Offset: 0x000148C8
        public static PlayerMatchStats Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            PlayerMatchStats playerMatchStats = new PlayerMatchStats();

            playerMatchStats.Cmid             = Int32Proxy.Deserialize(bytes);
            playerMatchStats.Death            = Int32Proxy.Deserialize(bytes);
            playerMatchStats.HasFinishedMatch = BooleanProxy.Deserialize(bytes);
            playerMatchStats.HasWonMatch      = BooleanProxy.Deserialize(bytes);
            playerMatchStats.Headshots        = Int32Proxy.Deserialize(bytes);
            playerMatchStats.Hits             = Int64Proxy.Deserialize(bytes);
            playerMatchStats.Kills            = Int32Proxy.Deserialize(bytes);
            playerMatchStats.Nutshots         = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                playerMatchStats.PersonalRecord = PlayerPersonalRecordStatisticsViewProxy.Deserialize(bytes);
            }
            playerMatchStats.Shots           = Int64Proxy.Deserialize(bytes);
            playerMatchStats.Smackdowns      = Int32Proxy.Deserialize(bytes);
            playerMatchStats.TimeSpentInGame = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                playerMatchStats.WeaponStatistics = PlayerWeaponStatisticsViewProxy.Deserialize(bytes);
            }
            return(playerMatchStats);
        }
Beispiel #7
0
        // Token: 0x0600106B RID: 4203 RVA: 0x00014918 File Offset: 0x00012B18
        public static void Serialize(Stream stream, PackageView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.Bonus);
                if (instance.Items != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.Items, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.Name != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Name);
                }
                else
                {
                    num |= 2;
                }
                DecimalProxy.Serialize(memoryStream, instance.Price);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #8
0
        // Token: 0x060010D8 RID: 4312 RVA: 0x00017FC8 File Offset: 0x000161C8
        public static AuthenticateApplicationView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            AuthenticateApplicationView authenticateApplicationView = new AuthenticateApplicationView();

            if ((num & 1) != 0)
            {
                authenticateApplicationView.CommServer = PhotonViewProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                authenticateApplicationView.EncryptionInitVector = StringProxy.Deserialize(bytes);
            }
            if ((num & 4) != 0)
            {
                authenticateApplicationView.EncryptionPassPhrase = StringProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                authenticateApplicationView.GameServers = ListProxy <PhotonView> .Deserialize(bytes, new ListProxy <PhotonView> .Deserializer <PhotonView>(PhotonViewProxy.Deserialize));
            }
            authenticateApplicationView.IsEnabled  = BooleanProxy.Deserialize(bytes);
            authenticateApplicationView.WarnPlayer = BooleanProxy.Deserialize(bytes);
            return(authenticateApplicationView);
        }
 // Token: 0x060010EB RID: 4331 RVA: 0x00018D98 File Offset: 0x00016F98
 public static void Serialize(Stream stream, PlayerWeaponStatisticsView instance)
 {
     using (MemoryStream memoryStream = new MemoryStream())
     {
         Int32Proxy.Serialize(memoryStream, instance.CannonTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.CannonTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.CannonTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.CannonTotalSplats);
         Int32Proxy.Serialize(memoryStream, instance.LauncherTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.LauncherTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.LauncherTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.LauncherTotalSplats);
         Int32Proxy.Serialize(memoryStream, instance.MachineGunTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.MachineGunTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.MachineGunTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.MachineGunTotalSplats);
         Int32Proxy.Serialize(memoryStream, instance.MeleeTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.MeleeTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.MeleeTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.MeleeTotalSplats);
         Int32Proxy.Serialize(memoryStream, instance.ShotgunTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.ShotgunTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.ShotgunTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.ShotgunTotalSplats);
         Int32Proxy.Serialize(memoryStream, instance.SniperTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.SniperTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.SniperTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.SniperTotalSplats);
         Int32Proxy.Serialize(memoryStream, instance.SplattergunTotalDamageDone);
         Int32Proxy.Serialize(memoryStream, instance.SplattergunTotalShotsFired);
         Int32Proxy.Serialize(memoryStream, instance.SplattergunTotalShotsHit);
         Int32Proxy.Serialize(memoryStream, instance.SplattergunTotalSplats);
         memoryStream.WriteTo(stream);
     }
 }
Beispiel #10
0
        // Token: 0x06001061 RID: 4193 RVA: 0x000142E0 File Offset: 0x000124E0
        public static void Serialize(Stream stream, MemberView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.MemberItems != null)
                {
                    ListProxy <int> .Serialize(memoryStream, instance.MemberItems, new ListProxy <int> .Serializer <int>(Int32Proxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.MemberWallet != null)
                {
                    MemberWalletViewProxy.Serialize(memoryStream, instance.MemberWallet);
                }
                else
                {
                    num |= 2;
                }
                if (instance.PublicProfile != null)
                {
                    PublicProfileViewProxy.Serialize(memoryStream, instance.PublicProfile);
                }
                else
                {
                    num |= 4;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #11
0
        // Token: 0x06001049 RID: 4169 RVA: 0x00013118 File Offset: 0x00011318
        public static void Serialize(Stream stream, ContactGroupView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Contacts != null)
                {
                    ListProxy <PublicProfileView> .Serialize(memoryStream, instance.Contacts, new ListProxy <PublicProfileView> .Serializer <PublicProfileView>(PublicProfileViewProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.GroupId);
                if (instance.GroupName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.GroupName);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #12
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 #13
0
        public static ApplicationConfigurationView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            ApplicationConfigurationView applicationConfigurationView = new ApplicationConfigurationView();

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

            using (MemoryStream memoryStream = new MemoryStream())
            {
                Int32Proxy.Serialize(memoryStream, instance.CreditsAttributed);
                BooleanProxy.Serialize(memoryStream, instance.ExposeItemsToPlayers);
                Int32Proxy.Serialize(memoryStream, instance.Id);
                if (instance.ImageUrl != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ImageUrl);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.LuckyDrawId);
                if (instance.LuckyDrawSetItems != null)
                {
                    ListProxy <BundleItemView> .Serialize(memoryStream, instance.LuckyDrawSetItems, new ListProxy <BundleItemView> .Serializer <BundleItemView>(BundleItemViewProxy.Serialize));
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(memoryStream, instance.PointsAttributed);
                Int32Proxy.Serialize(memoryStream, instance.SetWeight);
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x060010EF RID: 4335 RVA: 0x0001915C File Offset: 0x0001735C
        public static void Serialize(Stream stream, UberstrikeMemberView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.PlayerCardView != null)
                {
                    PlayerCardViewProxy.Serialize(memoryStream, instance.PlayerCardView);
                }
                else
                {
                    num |= 1;
                }
                if (instance.PlayerStatisticsView != null)
                {
                    PlayerStatisticsViewProxy.Serialize(memoryStream, instance.PlayerStatisticsView);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
 // Token: 0x060010EC RID: 4332 RVA: 0x00018F30 File Offset: 0x00017130
 public static PlayerWeaponStatisticsView Deserialize(Stream bytes)
 {
     return(new PlayerWeaponStatisticsView
     {
         CannonTotalDamageDone = Int32Proxy.Deserialize(bytes),
         CannonTotalShotsFired = Int32Proxy.Deserialize(bytes),
         CannonTotalShotsHit = Int32Proxy.Deserialize(bytes),
         CannonTotalSplats = Int32Proxy.Deserialize(bytes),
         LauncherTotalDamageDone = Int32Proxy.Deserialize(bytes),
         LauncherTotalShotsFired = Int32Proxy.Deserialize(bytes),
         LauncherTotalShotsHit = Int32Proxy.Deserialize(bytes),
         LauncherTotalSplats = Int32Proxy.Deserialize(bytes),
         MachineGunTotalDamageDone = Int32Proxy.Deserialize(bytes),
         MachineGunTotalShotsFired = Int32Proxy.Deserialize(bytes),
         MachineGunTotalShotsHit = Int32Proxy.Deserialize(bytes),
         MachineGunTotalSplats = Int32Proxy.Deserialize(bytes),
         MeleeTotalDamageDone = Int32Proxy.Deserialize(bytes),
         MeleeTotalShotsFired = Int32Proxy.Deserialize(bytes),
         MeleeTotalShotsHit = Int32Proxy.Deserialize(bytes),
         MeleeTotalSplats = Int32Proxy.Deserialize(bytes),
         ShotgunTotalDamageDone = Int32Proxy.Deserialize(bytes),
         ShotgunTotalShotsFired = Int32Proxy.Deserialize(bytes),
         ShotgunTotalShotsHit = Int32Proxy.Deserialize(bytes),
         ShotgunTotalSplats = Int32Proxy.Deserialize(bytes),
         SniperTotalDamageDone = Int32Proxy.Deserialize(bytes),
         SniperTotalShotsFired = Int32Proxy.Deserialize(bytes),
         SniperTotalShotsHit = Int32Proxy.Deserialize(bytes),
         SniperTotalSplats = Int32Proxy.Deserialize(bytes),
         SplattergunTotalDamageDone = Int32Proxy.Deserialize(bytes),
         SplattergunTotalShotsFired = Int32Proxy.Deserialize(bytes),
         SplattergunTotalShotsHit = Int32Proxy.Deserialize(bytes),
         SplattergunTotalSplats = Int32Proxy.Deserialize(bytes)
     });
 }
        // Token: 0x060010CC RID: 4300 RVA: 0x0001744C File Offset: 0x0001564C
        public static GameRoomData Deserialize(Stream bytes)
        {
            int          num          = Int32Proxy.Deserialize(bytes);
            GameRoomData gameRoomData = new GameRoomData();

            gameRoomData.ConnectedPlayers = Int32Proxy.Deserialize(bytes);
            gameRoomData.GameFlags        = Int32Proxy.Deserialize(bytes);
            gameRoomData.GameMode         = EnumProxy <GameModeType> .Deserialize(bytes);

            if ((num & 1) != 0)
            {
                gameRoomData.Guid = StringProxy.Deserialize(bytes);
            }
            gameRoomData.IsPasswordProtected = BooleanProxy.Deserialize(bytes);
            gameRoomData.IsPermanentGame     = BooleanProxy.Deserialize(bytes);
            gameRoomData.KillLimit           = Int32Proxy.Deserialize(bytes);
            gameRoomData.LevelMax            = ByteProxy.Deserialize(bytes);
            gameRoomData.LevelMin            = ByteProxy.Deserialize(bytes);
            gameRoomData.MapID = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                gameRoomData.Name = StringProxy.Deserialize(bytes);
            }
            gameRoomData.Number      = Int32Proxy.Deserialize(bytes);
            gameRoomData.PlayerLimit = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                gameRoomData.Server = ConnectionAddressProxy.Deserialize(bytes);
            }
            gameRoomData.TimeLimit = Int32Proxy.Deserialize(bytes);
            return(gameRoomData);
        }
        // Token: 0x060010EA RID: 4330 RVA: 0x00018CDC File Offset: 0x00016EDC
        public static PlayerStatisticsView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            PlayerStatisticsView playerStatisticsView = new PlayerStatisticsView();

            playerStatisticsView.Cmid      = Int32Proxy.Deserialize(bytes);
            playerStatisticsView.Headshots = Int32Proxy.Deserialize(bytes);
            playerStatisticsView.Hits      = Int64Proxy.Deserialize(bytes);
            playerStatisticsView.Level     = Int32Proxy.Deserialize(bytes);
            playerStatisticsView.Nutshots  = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                playerStatisticsView.PersonalRecord = PlayerPersonalRecordStatisticsViewProxy.Deserialize(bytes);
            }
            playerStatisticsView.Shots           = Int64Proxy.Deserialize(bytes);
            playerStatisticsView.Splats          = Int32Proxy.Deserialize(bytes);
            playerStatisticsView.Splatted        = Int32Proxy.Deserialize(bytes);
            playerStatisticsView.TimeSpentInGame = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                playerStatisticsView.WeaponStatistics = PlayerWeaponStatisticsViewProxy.Deserialize(bytes);
            }
            playerStatisticsView.Xp = Int32Proxy.Deserialize(bytes);
            return(playerStatisticsView);
        }
Beispiel #19
0
        // Token: 0x060010DD RID: 4317 RVA: 0x00018200 File Offset: 0x00016400
        public static void Serialize(Stream stream, LiveFeedView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                DateTimeProxy.Serialize(memoryStream, instance.Date);
                if (instance.Description != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Description);
                }
                else
                {
                    num |= 1;
                }
                Int32Proxy.Serialize(memoryStream, instance.LivedFeedId);
                Int32Proxy.Serialize(memoryStream, instance.Priority);
                if (instance.Url != null)
                {
                    StringProxy.Serialize(memoryStream, instance.Url);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
        // Token: 0x0600103B RID: 4155 RVA: 0x00012960 File Offset: 0x00010B60
        public static void Serialize(Stream stream, CheckApplicationVersionView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.ClientVersion != null)
                {
                    ApplicationViewProxy.Serialize(memoryStream, instance.ClientVersion);
                }
                else
                {
                    num |= 1;
                }
                if (instance.CurrentVersion != null)
                {
                    ApplicationViewProxy.Serialize(memoryStream, instance.CurrentVersion);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #21
0
        // Token: 0x06001104 RID: 4356 RVA: 0x0001A4F0 File Offset: 0x000186F0
        public static MapView Deserialize(Stream bytes)
        {
            int     num     = Int32Proxy.Deserialize(bytes);
            MapView mapView = new MapView();

            if ((num & 1) != 0)
            {
                mapView.Description = StringProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                mapView.DisplayName = StringProxy.Deserialize(bytes);
            }
            mapView.IsBlueBox         = BooleanProxy.Deserialize(bytes);
            mapView.MapId             = Int32Proxy.Deserialize(bytes);
            mapView.MaxPlayers        = Int32Proxy.Deserialize(bytes);
            mapView.RecommendedItemId = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                mapView.SceneName = StringProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                mapView.Settings = DictionaryProxy <GameModeType, MapSettings> .Deserialize(bytes, new DictionaryProxy <GameModeType, MapSettings> .Deserializer <GameModeType>(EnumProxy <GameModeType> .Deserialize), new DictionaryProxy <GameModeType, MapSettings> .Deserializer <MapSettings>(MapSettingsProxy.Deserialize));
            }
            mapView.SupportedGameModes = Int32Proxy.Deserialize(bytes);
            mapView.SupportedItemClass = Int32Proxy.Deserialize(bytes);
            return(mapView);
        }
        // Token: 0x060010C0 RID: 4288 RVA: 0x00016AB0 File Offset: 0x00014CB0
        public static EndOfMatchData Deserialize(Stream bytes)
        {
            int            num            = Int32Proxy.Deserialize(bytes);
            EndOfMatchData endOfMatchData = new EndOfMatchData();

            endOfMatchData.HasWonMatch = BooleanProxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                endOfMatchData.MatchGuid = StringProxy.Deserialize(bytes);
            }
            endOfMatchData.MostEffecientWeaponId = Int32Proxy.Deserialize(bytes);
            if ((num & 2) != 0)
            {
                endOfMatchData.MostValuablePlayers = ListProxy <StatsSummary> .Deserialize(bytes, new ListProxy <StatsSummary> .Deserializer <StatsSummary>(StatsSummaryProxy.Deserialize));
            }
            if ((num & 4) != 0)
            {
                endOfMatchData.PlayerStatsBestPerLife = StatsCollectionProxy.Deserialize(bytes);
            }
            if ((num & 8) != 0)
            {
                endOfMatchData.PlayerStatsTotal = StatsCollectionProxy.Deserialize(bytes);
            }
            if ((num & 16) != 0)
            {
                endOfMatchData.PlayerXpEarned = DictionaryProxy <byte, ushort> .Deserialize(bytes, new DictionaryProxy <byte, ushort> .Deserializer <byte>(ByteProxy.Deserialize), new DictionaryProxy <byte, ushort> .Deserializer <ushort>(UInt16Proxy.Deserialize));
            }
            endOfMatchData.TimeInGameMinutes = Int32Proxy.Deserialize(bytes);
            return(endOfMatchData);
        }
Beispiel #23
0
        // Token: 0x06001117 RID: 4375 RVA: 0x0001AF98 File Offset: 0x00019198
        public static void Serialize(Stream stream, UberstrikeUserViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.CmuneMemberView != null)
                {
                    MemberViewProxy.Serialize(memoryStream, instance.CmuneMemberView);
                }
                else
                {
                    num |= 1;
                }
                if (instance.UberstrikeMemberView != null)
                {
                    UberstrikeMemberViewProxy.Serialize(memoryStream, instance.UberstrikeMemberView);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #24
0
        // Token: 0x06001052 RID: 4178 RVA: 0x000138F0 File Offset: 0x00011AF0
        public static GroupInvitationView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            GroupInvitationView groupInvitationView = new GroupInvitationView();

            groupInvitationView.GroupId           = Int32Proxy.Deserialize(bytes);
            groupInvitationView.GroupInvitationId = Int32Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                groupInvitationView.GroupName = StringProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                groupInvitationView.GroupTag = StringProxy.Deserialize(bytes);
            }
            groupInvitationView.InviteeCmid = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                groupInvitationView.InviteeName = StringProxy.Deserialize(bytes);
            }
            groupInvitationView.InviterCmid = Int32Proxy.Deserialize(bytes);
            if ((num & 8) != 0)
            {
                groupInvitationView.InviterName = StringProxy.Deserialize(bytes);
            }
            if ((num & 16) != 0)
            {
                groupInvitationView.Message = StringProxy.Deserialize(bytes);
            }
            return(groupInvitationView);
        }
Beispiel #25
0
        // Token: 0x06001065 RID: 4197 RVA: 0x000144C0 File Offset: 0x000126C0
        public static void Serialize(Stream stream, MessageThreadView instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                BooleanProxy.Serialize(memoryStream, instance.HasNewMessages);
                if (instance.LastMessagePreview != null)
                {
                    StringProxy.Serialize(memoryStream, instance.LastMessagePreview);
                }
                else
                {
                    num |= 1;
                }
                DateTimeProxy.Serialize(memoryStream, instance.LastUpdate);
                Int32Proxy.Serialize(memoryStream, instance.MessageCount);
                Int32Proxy.Serialize(memoryStream, instance.ThreadId);
                if (instance.ThreadName != null)
                {
                    StringProxy.Serialize(memoryStream, instance.ThreadName);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #26
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);
            }
        }
        // Token: 0x060010E4 RID: 4324 RVA: 0x000188D4 File Offset: 0x00016AD4
        public static PlayerCardView Deserialize(Stream bytes)
        {
            int            num            = Int32Proxy.Deserialize(bytes);
            PlayerCardView playerCardView = new PlayerCardView();

            playerCardView.Cmid = Int32Proxy.Deserialize(bytes);
            playerCardView.Hits = Int64Proxy.Deserialize(bytes);
            if ((num & 1) != 0)
            {
                playerCardView.Name = StringProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                playerCardView.Precision = StringProxy.Deserialize(bytes);
            }
            playerCardView.Ranking  = Int32Proxy.Deserialize(bytes);
            playerCardView.Shots    = Int64Proxy.Deserialize(bytes);
            playerCardView.Splats   = Int32Proxy.Deserialize(bytes);
            playerCardView.Splatted = Int32Proxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                playerCardView.TagName = StringProxy.Deserialize(bytes);
            }
            return(playerCardView);
        }
        // Token: 0x06001060 RID: 4192 RVA: 0x00014234 File Offset: 0x00012434
        public static MemberSessionDataView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            MemberSessionDataView memberSessionDataView = new MemberSessionDataView();

            memberSessionDataView.AccessLevel = EnumProxy <MemberAccessLevel> .Deserialize(bytes);

            if ((num & 1) != 0)
            {
                memberSessionDataView.AuthToken = StringProxy.Deserialize(bytes);
            }
            memberSessionDataView.Channel = EnumProxy <ChannelType> .Deserialize(bytes);

            if ((num & 2) != 0)
            {
                memberSessionDataView.ClanTag = StringProxy.Deserialize(bytes);
            }
            memberSessionDataView.Cmid      = Int32Proxy.Deserialize(bytes);
            memberSessionDataView.IsBanned  = BooleanProxy.Deserialize(bytes);
            memberSessionDataView.Level     = Int32Proxy.Deserialize(bytes);
            memberSessionDataView.LoginDate = DateTimeProxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                memberSessionDataView.Name = StringProxy.Deserialize(bytes);
            }
            memberSessionDataView.XP = Int32Proxy.Deserialize(bytes);
            return(memberSessionDataView);
        }
Beispiel #29
0
        // Token: 0x06001109 RID: 4361 RVA: 0x0001A7E8 File Offset: 0x000189E8
        public static void Serialize(Stream stream, PlaySpanHashesViewModel instance)
        {
            int num = 0;

            using (MemoryStream memoryStream = new MemoryStream())
            {
                if (instance.Hashes != null)
                {
                    DictionaryProxy <decimal, string> .Serialize(memoryStream, instance.Hashes, new DictionaryProxy <decimal, string> .Serializer <decimal>(DecimalProxy.Serialize), new DictionaryProxy <decimal, string> .Serializer <string>(StringProxy.Serialize));
                }
                else
                {
                    num |= 1;
                }
                if (instance.MerchTrans != null)
                {
                    StringProxy.Serialize(memoryStream, instance.MerchTrans);
                }
                else
                {
                    num |= 2;
                }
                Int32Proxy.Serialize(stream, ~num);
                memoryStream.WriteTo(stream);
            }
        }
Beispiel #30
0
        // Token: 0x0600105A RID: 4186 RVA: 0x00013E44 File Offset: 0x00012044
        public static LuckyDrawUnityView Deserialize(Stream bytes)
        {
            int num = Int32Proxy.Deserialize(bytes);
            LuckyDrawUnityView luckyDrawUnityView = new LuckyDrawUnityView();

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

            if ((num & 1) != 0)
            {
                luckyDrawUnityView.Description = StringProxy.Deserialize(bytes);
            }
            if ((num & 2) != 0)
            {
                luckyDrawUnityView.IconUrl = StringProxy.Deserialize(bytes);
            }
            luckyDrawUnityView.Id = Int32Proxy.Deserialize(bytes);
            luckyDrawUnityView.IsAvailableInShop = BooleanProxy.Deserialize(bytes);
            if ((num & 4) != 0)
            {
                luckyDrawUnityView.LuckyDrawSets = ListProxy <LuckyDrawSetUnityView> .Deserialize(bytes, new ListProxy <LuckyDrawSetUnityView> .Deserializer <LuckyDrawSetUnityView>(LuckyDrawSetUnityViewProxy.Deserialize));
            }
            if ((num & 8) != 0)
            {
                luckyDrawUnityView.Name = StringProxy.Deserialize(bytes);
            }
            luckyDrawUnityView.Price = Int32Proxy.Deserialize(bytes);
            luckyDrawUnityView.UberStrikeCurrencyType = EnumProxy <UberStrikeCurrencyType> .Deserialize(bytes);

            return(luckyDrawUnityView);
        }