protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
 {
     QACreateDecorationOperation.AddDecoration(ResponseBody.decorationId, Count, offlineDatabase);
     ClubPenguin.Net.Offline.PlayerAssets value = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
     value.Assets = ResponseBody.assets;
     offlineDatabase.Write(value);
 }
示例#2
0
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            SceneLayoutEntity value       = offlineDatabase.Read <SceneLayoutEntity>();
            SceneLayout       sceneLayout = value[SceneLayoutId];

            sceneLayout.lastModifiedDate = DateTime.UtcNow.GetTimeInMilliseconds();
            if (RequestBody.zoneId != null)
            {
                sceneLayout.zoneId = RequestBody.zoneId;
            }
            if (RequestBody.name != null)
            {
                sceneLayout.name = RequestBody.name;
            }
            sceneLayout.lightingId = RequestBody.lightingId;
            sceneLayout.musicId    = RequestBody.musicId;
            if (RequestBody.decorationsLayout != null)
            {
                sceneLayout.decorationsLayout = RequestBody.decorationsLayout;
            }
            if (RequestBody.extraInfo != null)
            {
                sceneLayout.extraInfo = RequestBody.extraInfo;
            }
            offlineDatabase.Write(value);
            ResponseBody = SavedSceneLayout.FromSceneLayout(sceneLayout, SceneLayoutId);
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            CustomEquipmentCollection value = offlineDatabase.Read <CustomEquipmentCollection>();

            value.Equipment.Clear();
            offlineDatabase.Write(value);
        }
示例#4
0
        private BreadcrumbCollection updateBreadCrumbs(OfflineDatabase offlineDatabase)
        {
            BreadcrumbCollection breadcrumbCollection = offlineDatabase.Read <BreadcrumbCollection>();

            breadcrumbCollection.breadcrumbs.Clear();
            offlineDatabase.Write(breadcrumbCollection);
            return(breadcrumbCollection);
        }
 protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
 {
     ClubPenguin.Net.Offline.PlayerAssets playerAssets = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
     ResponseBody = new RewardCalculatedResponse
     {
         coins = offlineDefinitions.GetCoinsForExchange(playerAssets.Assets.collectibleCurrencies)
     };
 }
        public static QuestChangeResponse SetProgress(QuestObjectives objectives, OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            QuestStates.QuestState questState          = null;
            QuestStates            questStates         = offlineDatabase.Read <QuestStates>();
            QuestChangeResponse    questChangeResponse = new QuestChangeResponse();

            foreach (QuestStates.QuestState quest in questStates.Quests)
            {
                if (quest.status == QuestStatus.ACTIVE)
                {
                    questState = quest;
                    break;
                }
            }
            if (questState == null)
            {
                return(questChangeResponse);
            }
            if (questState.completedObjectives == null)
            {
                questState.completedObjectives = new QuestObjectives();
            }
            Reward reward = null;

            if (questState.timesCompleted == 0)
            {
                Dictionary <string, Reward> objectiveRewards = offlineDefinitions.QuestRewards(questState.questId).ObjectiveRewards;
                foreach (string objective in objectives)
                {
                    if (!questState.completedObjectives.Contains(objective) && objectiveRewards.ContainsKey(objective))
                    {
                        if (reward == null)
                        {
                            reward = new Reward();
                        }
                        reward.AddReward(objectiveRewards[objective]);
                    }
                }
            }
            if (reward != null)
            {
                offlineDefinitions.AddReward(reward, questChangeResponse);
            }
            questState.completedObjectives = objectives;
            offlineDatabase.Write(questStates);
            questChangeResponse.questId = questState.questId;
            questChangeResponse.questStateCollection = new SignedResponse <QuestStateCollection>
            {
                Data = GetQuestStateCollection(questStates, offlineDefinitions, includeComplete: false)
            };
            if (reward != null)
            {
                JsonService jsonService = Service.Get <JsonService>();
                questChangeResponse.reward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward)));
            }
            return(questChangeResponse);
        }
示例#7
0
 protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
 {
     if (offlineDefinitions.IsOwnIgloo(IglooId))
     {
         IglooEntity value = offlineDatabase.Read <IglooEntity>();
         value.Data.activeLayout = SignedJoinRoomData.Data.extraLayoutData;
         offlineDatabase.Write(value);
     }
 }
示例#8
0
        protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            ClubPenguin.Net.Offline.PlayerAssets value = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
            value.Assets = Response.assets;
            offlineDatabase.Write(value);
            DecorationInventoryEntity value2     = offlineDatabase.Read <DecorationInventoryEntity>();
            Dictionary <string, int>  dictionary = new Dictionary <string, int>();

            foreach (DecorationInventoryItem item in Response.decorationInventory.Data.items)
            {
                dictionary.Add(item.decorationId.ToString(), item.count);
            }
            value2.inventory = dictionary;
            offlineDatabase.Write(value2);
            ClubPenguin.Net.Offline.ConsumableInventory value3 = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
            value3.Inventory = Response.inventory.Data.inventoryMap;
            offlineDatabase.Write(value3);
        }
示例#9
0
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            DecorationInventoryEntity value = offlineDatabase.Read <DecorationInventoryEntity>();

            if (value.inventory.ContainsKey(DecorationId))
            {
                value.inventory.Remove(DecorationId);
                offlineDatabase.Write(value);
            }
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            DecorationId decorationId = new DecorationId(DefinitionId, (DecorationType)Type);

            AddDecoration(decorationId, Count, offlineDatabase);
            ResponseBody = new CreateDecorationResponse
            {
                assets       = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>().Assets,
                decorationId = decorationId
            };
        }
        private BreadcrumbCollection updateBreadCrumbs(OfflineDatabase offlineDatabase)
        {
            BreadcrumbCollection breadcrumbCollection = offlineDatabase.Read <BreadcrumbCollection>();

            foreach (Breadcrumb breadcrumb in BreadcrumbList)
            {
                breadcrumbCollection.breadcrumbs.Remove(breadcrumb);
            }
            offlineDatabase.Write(breadcrumbCollection);
            return(breadcrumbCollection);
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            TutorialData value = offlineDatabase.Read <TutorialData>();

            value.Init();
            offlineDatabase.Write(value);
            TutorialResponse = new TutorialResponse
            {
                tutorialBytes = new List <sbyte>(value.Bytes)
            };
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            SceneLayoutEntity value = offlineDatabase.Read <SceneLayoutEntity>();
            int    count            = value.Layouts.Count;
            Random random           = new Random();

            byte[] array = new byte[8];
            random.NextBytes(array);
            SavedSceneLayout savedSceneLayout = new SavedSceneLayout();

            savedSceneLayout.createdDate       = DateTime.UtcNow.GetTimeInMilliseconds();
            savedSceneLayout.decorationsLayout = RequestBody.decorationsLayout;
            savedSceneLayout.extraInfo         = RequestBody.extraInfo;
            savedSceneLayout.lastModifiedDate  = DateTime.UtcNow.GetTimeInMilliseconds();
            savedSceneLayout.layoutId          = BitConverter.ToInt64(array, 0);
            savedSceneLayout.lightingId        = RequestBody.lightingId;
            savedSceneLayout.memberOnly        = true;
            savedSceneLayout.musicId           = RequestBody.musicId;
            savedSceneLayout.name   = RequestBody.name;
            savedSceneLayout.zoneId = RequestBody.zoneId;
            SavedSceneLayout savedSceneLayout2 = savedSceneLayout;

            if (savedSceneLayout2.decorationsLayout == null)
            {
                savedSceneLayout2.decorationsLayout = new List <DecorationLayout>();
            }
            if (savedSceneLayout2.extraInfo == null)
            {
                savedSceneLayout2.extraInfo = new Dictionary <string, string>();
            }
            if (count == 0)
            {
                IglooEntity value2 = offlineDatabase.Read <IglooEntity>();
                value2.Data.activeLayout   = savedSceneLayout2;
                value2.Data.activeLayoutId = savedSceneLayout2.layoutId;
                offlineDatabase.Write(value2);
            }
            value.Layouts.Add(savedSceneLayout2);
            offlineDatabase.Write(value);
            ResponseBody = savedSceneLayout2;
        }
示例#14
0
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            DecorationId decorationId = ClubPenguin.Net.Domain.Decoration.DecorationId.FromString(DecorationId);

            QACreateDecorationOperation.AddDecoration(decorationId, Count, offlineDatabase);
            offlineDefinitions.SubtractDecorationCost(decorationId, Count);
            ResponseBody = new UpdateDecorationResponse
            {
                assets       = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>().Assets,
                decorationId = decorationId
            };
        }
示例#15
0
        protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            DecorationInventoryEntity value      = offlineDatabase.Read <DecorationInventoryEntity>();
            Dictionary <string, int>  dictionary = new Dictionary <string, int>();

            foreach (DecorationInventoryItem item in DecorationInventory.items)
            {
                dictionary.Add(item.decorationId.ToString(), item.count);
            }
            value.inventory = dictionary;
            offlineDatabase.Write(value);
        }
示例#16
0
 protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
 {
     ResponseBody = new RewardGrantedResponse();
     foreach (KeyValuePair <string, RewardJsonReader> reward in RequestBody.Data.rewards)
     {
         if (reward.Key == clubPenguinClient.PlayerSessionId.ToString())
         {
             offlineDefinitions.AddReward(reward.Value.ToReward(), ResponseBody);
         }
     }
     ResponseBody.assets = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>().Assets;
 }
        protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            TubeData value = offlineDatabase.Read <TubeData>();

            value.EquippedTubeId = SignedJoinRoomData.Data.selectedTubeId;
            offlineDatabase.Write(value);
            ClubPenguin.Net.Offline.ConsumableInventory value2 = offlineDatabase.Read <ClubPenguin.Net.Offline.ConsumableInventory>();
            value2.Inventory = SignedJoinRoomData.Data.playerRoomData.consumableInventory.inventoryMap;
            offlineDatabase.Write(value2);
            ClubPenguin.Net.Offline.PlayerAssets value3 = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
            value3.Assets = SignedJoinRoomData.Data.playerRoomData.assets;
            offlineDatabase.Write(value3);
            ClubPenguin.Net.Offline.PlayerOutfitDetails value4 = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerOutfitDetails>();
            value4.Parts = new List <CustomEquipment>(SignedJoinRoomData.Data.playerRoomData.outfit.parts);
            offlineDatabase.Write(value4);
            ClubPenguin.Net.Offline.Profile value5 = offlineDatabase.Read <ClubPenguin.Net.Offline.Profile>();
            value5.Colour      = SignedJoinRoomData.Data.playerRoomData.profile.colour;
            value5.DateCreated = DateTime.UtcNow.AddDays(-1 * SignedJoinRoomData.Data.playerRoomData.profile.daysOld).GetTimeInMilliseconds();
            offlineDatabase.Write(value5);
            SetProgressOperation.SetOfflineQuestStateCollection(offlineDatabase, SignedJoinRoomData.Data.playerRoomData.quests);
        }
示例#18
0
        private BreadcrumbCollection updateBreadCrumbs(OfflineDatabase offlineDatabase)
        {
            BreadcrumbCollection breadcrumbCollection = offlineDatabase.Read <BreadcrumbCollection>();

            breadcrumbCollection.breadcrumbs.AddRange(BreadcrumbList);
            if (breadcrumbCollection.breadcrumbs.Count > 50)
            {
                breadcrumbCollection.breadcrumbs.RemoveRange(0, breadcrumbCollection.breadcrumbs.Count - 50);
            }
            offlineDatabase.Write(breadcrumbCollection);
            return(breadcrumbCollection);
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            ClubPenguin.Net.Offline.PlayerAssets value = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>();
            int coinsForExchange = offlineDefinitions.GetCoinsForExchange(value.Assets.collectibleCurrencies);

            value.Assets.coins += coinsForExchange;
            value.Assets.collectibleCurrencies.Clear();
            offlineDatabase.Write(value);
            ResponseBody = new RewardGrantedResponse
            {
                assets = value.Assets
            };
        }
示例#20
0
 protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
 {
     DecorationInventory       = new DecorationInventory();
     DecorationInventory.items = new List <DecorationInventoryItem>();
     foreach (KeyValuePair <string, int> item in offlineDatabase.Read <DecorationInventoryEntity>().inventory)
     {
         DecorationInventory.items.Add(new DecorationInventoryItem
         {
             decorationId = DecorationId.FromString(item.Key),
             count        = item.Value
         });
     }
 }
 protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
 {
     ClubPenguin.Net.Offline.DailySpinData value = offlineDatabase.Read <ClubPenguin.Net.Offline.DailySpinData>();
     value.CurrentChestId                    = requestBody.CurrentChestId;
     value.NumPunchesOnCurrentChest          = requestBody.NumPunchesOnCurrentChest;
     value.NumChestsReceivedOfCurrentChestId = requestBody.NumChestsReceivedOfCurrentChestId;
     value.TimeOfLastSpinInMilliseconds      = requestBody.TimeOfLastSpinInMilliseconds;
     if (requestBody.ResetRewards)
     {
         value.EarnedNonRepeatableRewardIds.Clear();
         value.EarnedRepeatableRewardIds.Clear();
     }
     offlineDatabase.Write(value);
 }
        protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            CustomEquipmentCollection value = offlineDatabase.Read <CustomEquipmentCollection>();

            foreach (CustomEquipment item in value.Equipment)
            {
                if (item.equipmentId == EquipmentId)
                {
                    value.Equipment.Remove(item);
                    break;
                }
            }
            offlineDatabase.Write(value);
        }
        public static void AddDecoration(DecorationId decoration, int count, OfflineDatabase offlineDatabase)
        {
            DecorationInventoryEntity value = offlineDatabase.Read <DecorationInventoryEntity>();

            if (value.Inventory.ContainsKey(decoration))
            {
                value.Inventory[decoration] += count;
            }
            else
            {
                value.Inventory[decoration] = count;
            }
            offlineDatabase.Write(value);
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            IglooEntity value = offlineDatabase.Read <IglooEntity>();

            if (RequestBody.visibility.HasValue)
            {
                value.Data.visibility = RequestBody.visibility;
            }
            if (RequestBody.activeLayoutId.HasValue)
            {
                SceneLayoutEntity sceneLayoutEntity = offlineDatabase.Read <SceneLayoutEntity>();
                if (sceneLayoutEntity[RequestBody.activeLayoutId.Value] != null)
                {
                    value.Data.activeLayout   = sceneLayoutEntity[RequestBody.activeLayoutId.Value];
                    value.Data.activeLayoutId = RequestBody.activeLayoutId;
                }
            }
            offlineDatabase.Write(value);
            SignedResponseBody = new SignedResponse <IglooData>
            {
                Data = value.Data
            };
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            TubeData value = offlineDatabase.Read <TubeData>();

            value.EquippedTubeId = TubeId;
            offlineDatabase.Write(value);
            SignedEquipTubeResponse = new SignedResponse <EquipTubeResponse>
            {
                Data = new EquipTubeResponse
                {
                    tubeId = TubeId
                }
            };
        }
示例#26
0
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            SceneLayoutEntity value = offlineDatabase.Read <SceneLayoutEntity>();

            for (int i = 0; i < value.Layouts.Count; i++)
            {
                if (value.Layouts[i].layoutId == SceneLayoutId)
                {
                    value.Layouts.RemoveAt(i);
                    break;
                }
            }
            offlineDatabase.Write(value);
        }
        protected override void SetOfflineData(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            TutorialData value = offlineDatabase.Read <TutorialData>();

            for (int i = 0; i < value.Bytes.Length; i++)
            {
                sbyte b = 0;
                if (i < TutorialResponse.tutorialBytes.Count)
                {
                    b = TutorialResponse.tutorialBytes[i];
                }
                value.Bytes[i] = b;
            }
            offlineDatabase.Write(value);
        }
示例#28
0
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            string world = "Igloo";

            switch (LocalizationLanguage.GetLanguageFromLanguageString(Language))
            {
            case DevonLocalization.Core.Language.es_LA:
                world = "Iglú";
                break;

            case DevonLocalization.Core.Language.fr_FR:
                world = "Iglou";
                break;

            case DevonLocalization.Core.Language.pt_BR:
                world = "Iglu";
                break;
            }
            SignedJoinRoomData = PostRoomPlayersOperation.JoinRoom(world, Language, IglooId, offlineDatabase, offlineDefinitions);
            SignedJoinRoomData.Data.extraLayoutData = offlineDatabase.Read <IglooEntity>().Data.activeLayout;
            if (SignedJoinRoomData.Data.extraLayoutData == null)
            {
                SignedJoinRoomData.Data.extraLayoutData = new SceneLayout
                {
                    zoneId = IglooId.name
                };
            }
            RegistrationProfile registrationProfile = offlineDatabase.Read <RegistrationProfile>();

            SignedJoinRoomData.Data.roomOwnerName = registrationProfile.displayName;
            if (string.IsNullOrEmpty(SignedJoinRoomData.Data.roomOwnerName))
            {
                SignedJoinRoomData.Data.roomOwnerName = registrationProfile.userName;
            }
            SignedJoinRoomData.Data.roomOwner = true;
        }
        protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            Random random = new Random();

            byte[] array = new byte[8];
            random.NextBytes(array);
            long equipmentId = BitConverter.ToInt64(array, 0);

            createEquipment(equipmentId, offlineDatabase, offlineDefinitions);
            CustomEquipmentResponse = new CreateEquipmentResponse
            {
                assets      = offlineDatabase.Read <ClubPenguin.Net.Offline.PlayerAssets>().Assets,
                equipmentId = equipmentId
            };
        }
        private void createEquipment(long equipmentId, OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
        {
            CustomEquipmentCollection value           = offlineDatabase.Read <CustomEquipmentCollection>();
            CustomEquipment           customEquipment = default(CustomEquipment);

            customEquipment.dateTimeCreated = DateTime.UtcNow.GetTimeInMilliseconds();
            customEquipment.definitionId    = CustomEquipmentRequest.definitionId;
            customEquipment.equipmentId     = equipmentId;
            customEquipment.parts           = CustomEquipmentRequest.parts;
            CustomEquipment item = customEquipment;

            value.Equipment.Add(item);
            offlineDefinitions.SubtractEquipmentCost(item.definitionId);
            offlineDatabase.Write(value);
        }