private void ProcessResults(WaitableTask <Dictionary <int, EncounterBasicStatus> > result, TaskResult <string[]> fileTexts)
{
if (!fileTexts.HasValue())
{
result.SetResult(new Dictionary <int, EncounterBasicStatus>());
return;
}
var statuses = new Dictionary <int, EncounterBasicStatus>();
foreach (var fileText in fileTexts.Value)
{
var metadata = parser.Deserialize(fileText);
if (statuses.ContainsKey(metadata.Key))
{
Debug.LogError($"Duplicate saved status for key {metadata.Key}");
continue;
}
if (metadata.Value != null)
{
statuses.Add(metadata.Key, metadata.Value);
}
}
result.SetResult(statuses);
}
private void ProcessResults(WaitableTask <Dictionary <int, EncounterBasicStatus> > result,
List <WaitableTask <Dictionary <int, EncounterBasicStatus> > > listResults)
{
if (result.IsCompleted())
{
return;
}
foreach (var statusesResult in listResults)
{
if (!statusesResult.IsCompleted())
{
return;
}
}
var statuses = new Dictionary <int, EncounterBasicStatus>();;
for (int i = 0; i < listResults.Count; i++)
{
if (listResults[i].Result.HasValue())
{
statuses = CombineStatuses(statuses, listResults[i].Result.Value);
}
}
result.SetResult(statuses);
}
protected void ProcessWebrequest(UnityWebRequest webRequest, WaitableTask <string> result)
{
try {
var serverResult = GetResults(webRequest);
webRequest.Dispose();
result.SetResult(serverResult);
} catch (WebException webException) {
webRequest.Dispose();
result.SetError(webException);
}
}
protected virtual void SetFileResult(TaskResult <string> serverResult, WaitableTask <string> fileText)
{
if (serverResult.IsError())
{
fileText.SetError(serverResult.Exception);
}
else
{
fileText.SetResult(serverResult.Value);
}
}
private void ProcessResults(WaitableTask <List <EncounterMetadata> > result, TaskResult <string> serverOutput)
{
if (serverOutput == null || serverOutput.IsError())
{
result.SetError(serverOutput.Exception);
return;
}
var metadatas = parser.Deserialize(serverOutput.Value);
result.SetResult(metadatas);
}
protected virtual void CompleteMenuEncountersInfoTask(WaitableTask <IMenuEncountersInfo> task,
TaskResult <IMenuEncountersInfo> result, UserEncounter userEncounter)
{
if (userEncounter?.Status != null)
{
userEncounter.Status.BasicStatus.Completed = userEncounter.Status.ContentStatus.Read;
}
if (result.IsError())
{
task.SetError(result.Exception);
return;
}
if (result.Value == null)
{
task.SetResult(null);
return;
}
foreach (var encounter in result.Value.GetEncounters())
{
if (encounter.GetLatestMetadata().RecordNumber != userEncounter.Data.Metadata.RecordNumber)
{
continue;
}
if (userEncounter.Status != null)
{
encounter.Status = userEncounter.Status.BasicStatus;
}
else
{
encounter.Status = new EncounterBasicStatus();
}
break;
}
task.SetResult(result.Value);
}
protected void SetEncounters(TaskResult <string> serverResult)
{
if (demoEncounters == null || demoEncounters.IsCompleted() || serverResult.IsError())
{
demoEncounters.SetError(new Exception("Could not get demo encounters from file."));
return;
}
var splitChars = new char[] { '\n', '\r' };
var encounters = serverResult.Value.Split(splitChars, StringSplitOptions.RemoveEmptyEntries);
demoEncounters.SetResult(encounters);
}
protected void ProcessResults(User user,
WaitableTask <UserEncounter> result,
WaitableTask <Encounter> encounterData,
WaitableTask <EncounterStatus> detailedStatus)
{
if (result.IsCompleted() || !encounterData.IsCompleted() || !detailedStatus.IsCompleted())
{
return;
}
encounterData.Result.Value.Content.NonImageContent.Sections[0].Value.Tabs.Insert(0, "TOC", new Tab("Table Of Contents", "Table of Contents"));
var encounter = new UserEncounter(user, encounterData.Result.Value, detailedStatus.Result.Value);
SetEncounterStart(encounter);
result.SetResult(encounter);
}
protected virtual void ProcessResults(User user, WaitableTask <IMenuEncountersInfo> result, TaskResult <List <MenuEncounter> > menuEncounters)
{
if (menuEncounters.Value == null)
{
result.SetError(null);
return;
}
var menuEncountersInfo = new MenuEncountersInfo(user);
foreach (var menuEncounter in menuEncounters.Value)
{
menuEncountersInfo.AddEncounter(menuEncounter);
}
result.SetResult(menuEncountersInfo);
}
private void ProcessResult(WaitableTask <Dictionary <int, Dictionary <SaveType, EncounterMetadata> > > result,
Dictionary <SaveType, WaitableTask <List <EncounterMetadata> > > metadatasResults)
{
if (result.IsCompleted())
{
return;
}
foreach (var metadatasResult in metadatasResults)
{
if (!metadatasResult.Value.IsCompleted())
{
return;
}
}
var metadataGroups = new Dictionary <int, Dictionary <SaveType, EncounterMetadata> >();
foreach (var metadatasResult in metadatasResults)
{
if (!metadatasResult.Value.Result.HasValue())
{
continue;
}
foreach (var metadata in metadatasResult.Value.Result.Value)
{
AddMetadata(metadataGroups, metadatasResult.Key, metadata);
}
}
// Server metadata filename should be changed to match the local filename
// This ensures that the old files are properly renamed if using the server version
foreach (var metadataGroup in metadataGroups)
{
var group = metadataGroup.Value;
if (!group.ContainsKey(SaveType.Local) || !group.ContainsKey(SaveType.Server))
{
continue;
}
group[SaveType.Server].Filename = group[SaveType.Local].Filename;
}
result.SetResult(metadataGroups);
}
protected void ReadFiles(TaskResult <string[]> demoEncounters, WaitableTask <string[]> result, FileType fileType)
{
if (demoEncounters == null || !demoEncounters.HasValue() || demoEncounters.Value.Length == 0)
{
result.SetResult(new string[0]);
return;
}
var serverResults = new WaitableTask <string> [demoEncounters.Value.Length];
for (int i = 0; i < demoEncounters.Value.Length; i++)
{
var filePath = GetFile(fileType, demoEncounters.Value[i]);
var webRequest = UnityWebRequest.Get(filePath);
serverResults[i] = serverReader.Begin(webRequest);
serverResults[i].AddOnCompletedListener((serverResult) => SetFilesResults(result, serverResults));
}
}
private void ProcessResults(WaitableTask <User> result, TaskResult <string> serverResult)
{
if (serverResult.IsError() || string.IsNullOrWhiteSpace(serverResult.Value))
{
result.SetError(serverResult.Exception);
return;
}
var user = UserDeserializer.Deserialize(serverResult.Value);
if (user == null)
{
result.SetError(new Exception($"Could not parse user: {serverResult.Value}"));
}
else
{
result.SetResult(user);
}
}
private void ProcessResults(WaitableTask <List <EncounterMetadata> > result, TaskResult <string[]> fileTexts)
{
if (fileTexts == null)
{
result.SetError(null);
return;
}
var metadatas = new List <EncounterMetadata>();
foreach (var fileText in fileTexts.Value)
{
var metadata = parser.Deserialize(fileText);
if (metadata != null)
{
metadatas.Add(metadata);
}
}
result.SetResult(metadatas);
}
protected virtual void ProcessResults(
WaitableTask <Dictionary <int, EncounterEditLock> > result,
TaskResult <string> serverOutput)
{
if (serverOutput == null || serverOutput.IsError())
{
result.SetError(serverOutput.Exception);
return;
}
var locks = parser.Deserialize(serverOutput.Value);
var lockDictionary = new Dictionary <int, EncounterEditLock>();
foreach (var encounterLock in locks)
{
if (!lockDictionary.ContainsKey(encounterLock.RecordNumber))
{
lockDictionary.Add(encounterLock.RecordNumber, encounterLock);
}
}
result.SetResult(lockDictionary);
}
protected void SetFilesResults(WaitableTask <string[]> result, WaitableTask <string>[] serverResults)
{
foreach (var serverResult in serverResults)
{
if (serverResult == null || !serverResult.IsCompleted())
{
return;
}
}
var filesTexts = new List <string>();
foreach (var serverResult in serverResults)
{
if (!serverResult.Result.IsError())
{
filesTexts.Add(serverResult.Result.Value);
}
}
result.SetResult(filesTexts.ToArray());
}
protected virtual void ProcessResults(WaitableTask <List <MenuEncounter> > result,
WaitableTask <Dictionary <int, Dictionary <SaveType, EncounterMetadata> > > metadataGroups,
WaitableTask <Dictionary <int, EncounterEditLock> > locks,
WaitableTask <Dictionary <int, EncounterBasicStatus> > statuses)
{
if (result.IsCompleted() || !metadataGroups.IsCompleted() || !statuses.IsCompleted() || !locks.IsCompleted())
{
return;
}
if (metadataGroups.Result.Value == null)
{
result.SetError(null);
return;
}
var menuEncounters = new List <MenuEncounter>();
foreach (var metadataGroup in metadataGroups.Result.Value)
{
menuEncounters.Add(GetMenuEncounter(metadataGroup, locks, statuses));
}
result.SetResult(menuEncounters);
}
private void ProcessResults(WaitableTask <EncounterNonImageContent> result, TaskResult <string> serverResult)
{
result.SetResult(parser.Deserialize(serverResult.Value));
}