protected override void handleSessionMessage(PartyGameSessionMessageTypes type, string data)
{
switch (type)
{
case PartyGameSessionMessageTypes.SetRole:
{
PartyGameSessionMessages.SetRole setRole = jsonService.Deserialize <PartyGameSessionMessages.SetRole>(data);
role = (ScavengerHuntRoles)setRole.RoleId;
scavengerHuntData.LocalPlayerRole = role;
scavengerHuntData.OtherPlayerRole = ((role == ScavengerHuntRoles.Hider) ? ScavengerHuntRoles.Finder : ScavengerHuntRoles.Hider);
break;
}
case PartyGameSessionMessageTypes.SetGameState:
{
PartyGameSessionMessages.SetGameState setGameState = jsonService.Deserialize <PartyGameSessionMessages.SetGameState>(data);
ScavengerHuntState gameStateId = (ScavengerHuntState)setGameState.GameStateId;
changeState(gameStateId);
break;
}
case PartyGameSessionMessageTypes.RemoveItem:
handleRemoveItem(jsonService.Deserialize <PartyGameSessionMessages.RemoveItem>(data));
break;
case PartyGameSessionMessageTypes.AddItem:
handleAddItem(jsonService.Deserialize <PartyGameSessionMessages.AddItem>(data));
break;
}
}
protected override void handleSessionMessage(PartyGameSessionMessageTypes type, string data)
{
switch (type)
{
case PartyGameSessionMessageTypes.SetGameState:
{
PartyGameSessionMessages.SetGameState setGameState = jsonService.Deserialize <PartyGameSessionMessages.SetGameState>(data);
FishBucketState gameStateId = (FishBucketState)setGameState.GameStateId;
changeState(gameStateId);
break;
}
case PartyGameSessionMessageTypes.SetGameStartPositions:
handleSetGameStartPositions(jsonService.Deserialize <PartyGameSessionMessages.SetGameStartData>(data));
break;
case PartyGameSessionMessageTypes.ShowTurnOutput:
handleShowTurnOutput(jsonService.Deserialize <PartyGameSessionMessages.ShowTurnOutput>(data));
break;
case PartyGameSessionMessageTypes.PlayerTurnStart:
handlePlayerTurnStart(jsonService.Deserialize <PartyGameSessionMessages.PlayerTurnStart>(data));
break;
case PartyGameSessionMessageTypes.PlayerLeftGame:
handlePlayerLeftGame(jsonService.Deserialize <PartyGameSessionMessages.PlayerLeftGame>(data));
break;
case PartyGameSessionMessageTypes.AddItem:
case PartyGameSessionMessageTypes.RemoveItem:
break;
}
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ResponseBody = new ClaimDailySpinRewardResponse();
Reward reward = new Reward();
Reward reward2 = new Reward();
int spinResult = offlineDefinitions.GetSpinResult(reward, reward2);
offlineDefinitions.AddReward(reward, ResponseBody);
offlineDefinitions.AddReward(reward2, ResponseBody);
JsonService jsonService = Service.Get <JsonService>();
ResponseBody.spinOutcomeId = spinResult;
ResponseBody.reward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward)));
ResponseBody.chestReward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward2)));
}
public void DeserializeMethodShouldReturnRightResultObject()
{
//Arrange
var jsonToDeserialize = "{\"sources\":[{\"id\":\"dcfe1db6-2484-42c2-9d9e-a77a28a5078d\",\"name\":\"BKAL33+KBT T\",\"description\":\"Plato Chemicals Test\",\"sourceBusinessUnits\":[]}],\"operations\":[{\"id\":\"d2760435-9d0b-4b69-adce-09017f2840c6\",\"name\":\"Unload into warehouse\",\"description\":\"Unloading goods into the warehouse\",\"icon\":null,\"tags\":[\"string\"]}]}";
var jsonService = new JsonService();
var flowFilter = new FlowFilter(new List <FlowSource> {
new FlowSource("BKAL33+KBT T")
},
new List <FlowOperation> {
new FlowOperation("Unload into warehouse")
},
new List <FlowSite>(),
new List <FlowOperationalDepartment>(),
new List <FlowTypePlanning>(),
new List <FlowCustomer>(),
new List <FlowProductionSite>(),
new List <FlowTransportType>(),
"No");
//Act
var result = jsonService.Deserialize <FlowFilter>(jsonToDeserialize);
//Assert
result.Sources.Should().BeEquivalentTo(flowFilter.Sources);
result.Operations.Should().BeEquivalentTo(flowFilter.Operations);
}
public async Task InvokeAsync(
HttpContext context,
IContentStorage contentStore,
ISchemaStorage schemaStorage,
JsonService jsonService)
{
string schema = (string)context.GetRouteValue("schema");
QueryParameters queryParameters = await jsonService.Deserialize <QueryParameters>(context.Request.Body);
ContentSchema schemaModel = await schemaStorage.GetContentSchemaAsync(schema);
QueryResult <ContentItem> contentItems = await contentStore.Query(schema, queryParameters);
foreach (ContentItem contentItem in contentItems.Items)
{
contentItem.ApplySchema(schemaModel);
}
QueryResult <RestContentItem> resultQuery = new QueryResult <RestContentItem>()
{
Offset = contentItems.Offset,
Count = contentItems.Count,
TotalCount = contentItems.TotalCount,
Items = contentItems.Items.Select(x => x.ToRest()).ToList()
};
string json = jsonService.Serialize(resultQuery);
await context.Response.WriteAsync(json);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
Response = new FishingCatchResponse();
Reward fishingReward = offlineDefinitions.GetFishingReward(FishingCatchRequest.winningRewardName);
offlineDefinitions.AddReward(fishingReward, Response);
JsonService jsonService = Service.Get <JsonService>();
Dictionary <string, RewardJsonReader> dictionary = new Dictionary <string, RewardJsonReader>();
dictionary.Add(client.PlayerSessionId.ToString(), jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(fishingReward))));
Response.rewards = new SignedResponse <RewardedUserCollectionJsonHelper>
{
Data = new RewardedUserCollectionJsonHelper
{
rewards = dictionary,
source = RewardSource.MINI_GAME,
sourceId = "fishing"
}
};
if (Response.wsEvents == null)
{
Response.wsEvents = new List <SignedResponse <WebServiceEvent> >();
}
Response.wsEvents.Add(new SignedResponse <WebServiceEvent>
{
Data = new WebServiceEvent
{
type = 1,
details = new JsonData(FishingCatchRequest.winningRewardName)
}
});
}
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);
}
public void When_Json_Says_null_Then_Should_Return_Null()
{
string input = "null";
var jsonService = new JsonService();
var result = jsonService.Deserialize <FakeNullableData>(input);
result.Should().BeNull();
}
public void TestSerializationKeypad()
{
Keypad keypad = new Keypad();
JsonService js = new JsonService();
string JsonString = js.Serialize(keypad);
Keypad obj = js.Deserialize <Keypad>(JsonString);
Assert.AreEqual(keypad.UID, obj.UID);
}
protected override void PerformOfflineAction(OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
ResponseBody = new ClaimRewardResponse();
Reward quickNotificationReward = offlineDefinitions.GetQuickNotificationReward();
offlineDefinitions.AddReward(quickNotificationReward, ResponseBody);
JsonService jsonService = Service.Get <JsonService>();
ResponseBody.reward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(quickNotificationReward)));
}
public LoginPage(string Env)
{
inEnv = Env;
JsonService js = new JsonService();
LoadEnvironmentService les = new LoadEnvironmentService();
string json = les.LoadEnvironmentOjbect(inEnv);
env = js.Deserialize <EnvironmentC>(json);
InitializeComponent();
txtPassword.PasswordChar = '*';
}
public void TestSerializationUser()
{
User newUser = new User("bdr", "1234");
JsonService js = new JsonService();
string JsonString = js.Serialize(newUser);
User obj = new User();
obj = js.Deserialize <User>(JsonString);
Assert.AreEqual(newUser.Username, obj.Username);
//Assert.AreEqual(newUser.Username, afterJsonDeserialize.Username);
}
private void handleSetTubeRaceModifierLayout(string data)
{
try
{
PartyGameSessionMessages.SetTubeRaceModifierLayout setTubeRaceModifierLayout = jsonService.Deserialize <PartyGameSessionMessages.SetTubeRaceModifierLayout>(data);
eventDispatcher.DispatchEvent(new TubeRaceEvents.SetModifierLayout((PartyGameDefinition.GameTypes)partyGameId, setTubeRaceModifierLayout.ModifierLayoutId));
}
catch (Exception)
{
}
}
protected override void handleSessionMessage(PartyGameSessionMessageTypes type, string data)
{
switch (type)
{
case PartyGameSessionMessageTypes.SetGameState:
{
PartyGameSessionMessages.SetGameState setGameState = jsonService.Deserialize <PartyGameSessionMessages.SetGameState>(data);
FindFourState gameStateId = (FindFourState)setGameState.GameStateId;
changeState(gameStateId);
break;
}
case PartyGameSessionMessageTypes.ShowTurnOutput:
handleShowTurnOutput(jsonService.Deserialize <PartyGameSessionMessages.ShowTurnOutput>(data));
break;
case PartyGameSessionMessageTypes.PlayerTurnStart:
handlePlayerTurnStart(jsonService.Deserialize <PartyGameSessionMessages.PlayerTurnStart>(data));
break;
}
}
public async Task InvokeAsync(
HttpContext context,
ISchemaStorage schemaStorage,
JsonService jsonService)
{
Guid id = Guid.Parse((string)context.GetRouteValue("id"));
RestContentSchema input = await jsonService.Deserialize <RestContentSchema>(context.Request.Body);
ContentSchema m = input.ToModel();
await schemaStorage.UpdateAsync(m);
}
private void initializeTokenTypes()
{
jsonService = new LitJsonService();
TextAsset textAsset = Resources.Load <TextAsset>(TOKEN_TYPE_ASSET);
if (!(textAsset == null) && !string.IsNullOrEmpty(textAsset.text))
{
string text = textAsset.text;
tokenTypes = jsonService.Deserialize <Dictionary <string, string[]> >(text);
if (tokenTypes.Count > 0)
{
}
}
}
public void JsonService_CanDeserialize()
{
var json = "{\"Count\":5,\"Type\":\"Thingie\",\"Cost\":88.5}";
var expectedClass = new TestClass
{
Cost = 88.5,
Count = 5,
Type = "Thingie"
};
var val = JsonService.Deserialize <TestClass>(json);
Assert.AreEqual(expectedClass, val);
}
public void UpdateTokensFromJSONText(string jsonText, Action <bool> responseHandler)
{
Dictionary <string, string> dictionary = jsonService.Deserialize <Dictionary <string, string> >(jsonText);
if (dictionary == null || dictionary.Count == 0)
{
return;
}
bool obj = false;
foreach (KeyValuePair <string, string> item in dictionary)
{
string text = item.Value;
if (Language == Language.oversized)
{
int num = (int)((double)text.Length * 0.4) - 4;
string text2 = "";
if (num > 0)
{
int num2 = (int)Math.Floor((double)num / 6.0);
int num3 = num - num2 * 6;
for (int i = 0; i < num2; i++)
{
text2 = text2 + " " + Guid.NewGuid().ToString("N").Substring(0, 5);
}
if (num3 > 0)
{
text2 = text2 + " " + Guid.NewGuid().ToString("N").Substring(0, num3);
}
}
text = "@@" + text + text2 + "@@";
}
if (tokens.ContainsKey(item.Key))
{
obj = true;
tokens[item.Key] = text;
}
else
{
obj = true;
tokens.Add(item.Key, text);
}
}
responseHandler?.Invoke(obj);
if (TokensUpdated != null)
{
TokensUpdated();
}
}
public async Task InvokeAsync(
HttpContext context,
IAssetFolderStorage assetStore,
JsonService jsonService)
{
AssetFolderQuery query = await jsonService.Deserialize <AssetFolderQuery>(context.Request.Body);
IEnumerable <AssetFolder> assets = await assetStore.GetAssetFoldersAsync(query);
IEnumerable <RestAssetFolder> result = assets.Select(x => x.ToRest()).ToList();
string json = jsonService.Serialize(result);
await context.Response.WriteAsync(json);
}
public void When_Json_Does_Not_Contain_Elements_Then_Those_Elements_Should_Be_Null()
{
var input = "{\"FakeData\":\"This is some fake input\"}";
var jsonService = new JsonService();
var result = jsonService.Deserialize <FakeNullableData>(input);
var expectedResult = new FakeNullableData
{
FakeData = "This is some fake input"
};
result.Should().BeEquivalentTo(expectedResult);
}
public static void ImportData(string userName)
{
JsonService jsonService = Service.Get <JsonService>();
TextEditor textEditor = new TextEditor();
textEditor.Paste();
OfflineDataExport offlineDataExport = jsonService.Deserialize <OfflineDataExport>(textEditor.text);
if (string.IsNullOrEmpty(userName))
{
userName = offlineDataExport.UserName;
}
else
{
RegistrationProfile registrationProfile = OfflineDatabase.Read <RegistrationProfile>(RegistrationProfile.Id(userName));
if (!string.IsNullOrEmpty(registrationProfile.userName))
{
offlineDataExport.RegistrationProfile.displayName = registrationProfile.displayName;
offlineDataExport.RegistrationProfile.firstName = registrationProfile.firstName;
offlineDataExport.RegistrationProfile.parentEmail = registrationProfile.parentEmail;
}
else
{
offlineDataExport.RegistrationProfile.displayName = userName;
}
}
string token = RegistrationProfile.Id(userName);
offlineDataExport.RegistrationProfile.userName = userName;
OfflineDatabase.Write(offlineDataExport.BreadCrumbs, token);
OfflineDatabase.Write(offlineDataExport.ClaimableRewards, token);
OfflineDatabase.Write(offlineDataExport.ConsumableInventory, token);
OfflineDatabase.Write(offlineDataExport.Equipment, token);
OfflineDatabase.Write(offlineDataExport.DailySpinData, token);
OfflineDatabase.Write(offlineDataExport.IglooData, token);
OfflineDatabase.Write(offlineDataExport.RoomRewards, token);
OfflineDatabase.Write(offlineDataExport.Assets, token);
OfflineDatabase.Write(offlineDataExport.Outfit, token);
OfflineDatabase.Write(offlineDataExport.Profile, token);
OfflineDatabase.Write(offlineDataExport.QuestStates, token);
OfflineDatabase.Write(offlineDataExport.RegistrationProfile, token);
OfflineDatabase.Write(offlineDataExport.IglooLayouts, token);
OfflineDatabase.Write(offlineDataExport.Tube, token);
OfflineDatabase.Write(offlineDataExport.Tutorials, token);
}
protected void sendReward()
{
JsonService jsonService = Service.Get <JsonService>();
Dictionary <string, RewardJsonReader> dictionary = new Dictionary <string, RewardJsonReader>();
dictionary.Add(client.clubPenguinClient.PlayerSessionId.ToString(), jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(totalReward))));
SignedResponse <RewardedUserCollectionJsonHelper> signedResponse = new SignedResponse <RewardedUserCollectionJsonHelper>();
signedResponse.Data = new RewardedUserCollectionJsonHelper
{
rewards = dictionary,
source = RewardSource.WORLD_OBJECT,
sourceId = item.Id.Id.ToString()
};
SignedResponse <RewardedUserCollectionJsonHelper> data = signedResponse;
client.processEvent(GameServerEvent.RECEIVED_REWARDS, data);
}
public void EndSession(long userSessionId)
{
timer.Stop();
JsonService jsonService = Service.Get <JsonService>();
PartyGameSessionMessages.TubeRacePlayerResult tubeRacePlayerResult = new PartyGameSessionMessages.TubeRacePlayerResult();
tubeRacePlayerResult.CompletionTimeInMilliseconds = timer.ElapsedMilliseconds;
tubeRacePlayerResult.OverallScore = raceDefinition.StartingPoints - timer.ElapsedMilliseconds * raceDefinition.PointsDeductedPerSecond / 1000 + userScores[userSessionId];
tubeRacePlayerResult.PlayerId = userSessionId;
tubeRacePlayerResult.ScoreModifier = userScores[userSessionId];
PartyGameSessionMessages.TubeRacePlayerResult objectToSerialize = tubeRacePlayerResult;
PartyGameMessageEvent partyGameMessageEvent = default(PartyGameMessageEvent);
partyGameMessageEvent.sessionId = sessionId;
partyGameMessageEvent.type = 13;
partyGameMessageEvent.message = jsonService.Serialize(objectToSerialize);
PartyGameMessageEvent partyGameMessageEvent2 = partyGameMessageEvent;
processEvent(GameServerEvent.PARTY_GAME_MESSAGE, partyGameMessageEvent2);
if (Service.Get <IGameData>().Get <Dictionary <int, PartyGameDefinition> >().TryGetValue(cpItem.gameTemplateId, out var value))
{
foreach (PartyGameDefinition.PartyGameReward reward in value.Rewards)
{
if (reward.Placement == PartyGameEndPlacement.FIRST)
{
Dictionary <string, RewardJsonReader> dictionary = new Dictionary <string, RewardJsonReader>();
dictionary.Add(userSessionId.ToString(), jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward.Reward.ToReward()))));
SignedResponse <RewardedUserCollectionJsonHelper> signedResponse = new SignedResponse <RewardedUserCollectionJsonHelper>();
signedResponse.Data = new RewardedUserCollectionJsonHelper
{
rewards = dictionary,
source = RewardSource.MINI_GAME,
sourceId = sessionId.ToString()
};
SignedResponse <RewardedUserCollectionJsonHelper> arg = signedResponse;
processEvent(GameServerEvent.RECEIVED_REWARDS_DELAYED, arg);
break;
}
}
}
CoroutineRunner.StartPersistent(finishEndSession(), this, "finishEndSession");
}
public async Task InvokeAsync(
HttpContext context,
IAssetStorage assetStore,
JsonService jsonService)
{
RestAsset restAsset = await jsonService.Deserialize <RestAsset>(context.Request.Body);
Asset asset = restAsset.ToModel();
await assetStore.CreateAsync(asset);
var r = new ResourceCreated()
{
Id = asset.Id
};
string json = jsonService.Serialize(r);
await context.Response.WriteAsync(json);
}
public async Task InvokeAsync(
HttpContext context,
IAssetStorage assetStore,
JsonService jsonService)
{
AssetQuery query = await jsonService.Deserialize <AssetQuery>(context.Request.Body);
QueryResult <Asset> assets = await assetStore.GetAssetsAsync(query);
QueryResult <RestAsset> queryResult = new QueryResult <RestAsset>();
queryResult.Offset = assets.Offset;
queryResult.Count = assets.Count;
queryResult.TotalCount = assets.TotalCount;
queryResult.Items = assets.Items.Select(x => x.ToRest()).ToList();
string json = jsonService.Serialize(queryResult);
await context.Response.WriteAsync(json);
}
public async Task InvokeAsync(
HttpContext context,
IContentStorage contentStore,
JsonService jsonService)
{
RestContentItem input = await jsonService.Deserialize <RestContentItem>(context.Request.Body);
ContentItem model = input.ToModel();
await contentStore.UpdateAsync(model);
ResourceCreated result = new ResourceCreated()
{
Id = input.Id
};
string json = jsonService.Serialize(result);
await context.Response.WriteAsync(json);
}
private void onEvalJavaScriptFinished(string result)
{
if (string.IsNullOrEmpty(result) || result.Equals("undefined"))
{
return;
}
Dictionary <string, string> dictionary = jsonService.Deserialize <Dictionary <string, string> >(result);
if (dictionary != null && dictionary.ContainsKey("type") && dictionary.ContainsKey("status") && dictionary.ContainsKey("timestamp") && dictionary["type"].Equals("tokenLogin") && !receivedInitialLoginFunctionResponse && dictionary["status"] == "success")
{
webView.IsReadyToShow = true;
receivedInitialLoginFunctionResponse = true;
PlayerPrefs.SetInt("newsfeed_login_timestamp", Convert.ToInt32(dictionary["timestamp"]));
dataEntityCollection.RemoveComponent <NewPostData>(dataEntityCollection.LocalPlayerHandle);
if (this.NewsfeedLoginSucceeded != null)
{
this.NewsfeedLoginSucceeded();
this.NewsfeedLoginSucceeded = null;
}
}
}
public async Task InvokeAsync(
HttpContext context,
ISchemaStorage schemaStorage,
JsonService jsonService)
{
string name = (string)context.GetRouteValue("name");
RestContentSchema input = await jsonService.Deserialize <RestContentSchema>(context.Request.Body);
ContentSchema m = input.ToModel();
await schemaStorage.CreateAsync(m);
var result = new ResourceCreated()
{
Id = m.Id
};
string json = jsonService.Serialize(result);
await context.Response.WriteAsync(json);
}
internal static bool ClaimReward(int rewardId, out ClaimRewardResponse responseBody, OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
responseBody = new ClaimRewardResponse();
ClaimableRewardData value = offlineDatabase.Read <ClaimableRewardData>();
if (value.ClimedRewards.Contains(rewardId))
{
return(false);
}
Reward claimableReward = offlineDefinitions.GetClaimableReward(rewardId);
if (claimableReward != null)
{
offlineDefinitions.AddReward(claimableReward, responseBody);
value.ClimedRewards.Add(rewardId);
offlineDatabase.Write(value);
JsonService jsonService = Service.Get <JsonService>();
responseBody.reward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(claimableReward)));
return(true);
}
return(false);
}
public static QuestChangeResponse SetStatus(QuestStatus status, string questId, OfflineDatabase offlineDatabase, IOfflineDefinitionLoader offlineDefinitions)
{
QuestChangeResponse questChangeResponse = new QuestChangeResponse();
QuestStates questStates = offlineDatabase.Read <QuestStates>();
QuestStates.QuestState questState = null;
int num = -1;
for (int i = 0; i < questStates.Quests.Count; i++)
{
if (questStates.Quests[i].questId == questId)
{
questState = questStates.Quests[i];
num = i;
break;
}
}
QuestRewardsCollection questRewardsCollection = offlineDefinitions.QuestRewards(questId);
Reward reward = null;
if (questState == null)
{
reward = questRewardsCollection.StartReward;
if (reward != null)
{
if (reward.isEmpty())
{
reward = null;
}
else
{
offlineDefinitions.AddReward(reward, questChangeResponse);
}
}
questState = new QuestStates.QuestState();
questState.questId = questId;
}
if (status == QuestStatus.ACTIVE)
{
for (int i = 0; i < questStates.Quests.Count; i++)
{
if (questStates.Quests[i].status == QuestStatus.ACTIVE)
{
questStates.Quests[i].status = QuestStatus.SUSPENDED;
}
}
if (questState.status == QuestStatus.COMPLETED)
{
questState.completedObjectives.Clear();
}
}
if (status == QuestStatus.COMPLETED)
{
int timesCompleted = questState.timesCompleted;
if (timesCompleted == 0)
{
questState.completedTime = DateTime.UtcNow;
reward = questRewardsCollection.CompleteReward;
if (reward != null)
{
if (reward.isEmpty())
{
reward = null;
}
else
{
offlineDefinitions.AddReward(reward, questChangeResponse);
}
}
}
questState.timesCompleted = timesCompleted + 1;
}
questState.status = status;
if (num >= 0)
{
questStates.Quests[num] = questState;
}
else
{
questStates.Quests.Add(questState);
}
offlineDatabase.Write(questStates);
JsonService jsonService = Service.Get <JsonService>();
if (reward != null)
{
questChangeResponse.reward = jsonService.Deserialize <RewardJsonReader>(jsonService.Serialize(RewardJsonWritter.FromReward(reward)));
}
questChangeResponse.questId = questId;
questChangeResponse.questStateCollection = new SignedResponse <QuestStateCollection>
{
Data = SetProgressOperation.GetQuestStateCollection(questStates, offlineDefinitions, includeComplete: false)
};
return(questChangeResponse);
}
