public LoadingReaderSceneInfo(User user, ILoadingScreen loadingScreen, WaitableTask <UserEncounter> encounter)
{
User = user;
LoadingScreen = loadingScreen;
Encounter = encounter;
Encounter.AddOnCompletedListener(EncounterRetrieved);
}
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);
}
protected virtual void ProcessResults(WaitableTask result, TaskResult <string> serverOutput)
{
if (serverOutput == null || serverOutput.IsError())
{
result.SetError(serverOutput.Exception);
return;
}
var output = serverOutput.Value.Trim();
if (output.StartsWith("1"))
{
result.SetCompleted();
return;
}
string errorStart = "-1|";
if (output.StartsWith(errorStart, StringComparison.InvariantCultureIgnoreCase))
{
var encounterLock = parser.Deserialize(output.Substring(errorStart.Length));
result.SetError(new EncounterAlreadyLockedException(encounterLock));
return;
}
result.SetError(new Exception("Could not unlock the encounter."));
}
private void ProcessResults(WaitableTask actionResult, TaskResult <string> serverResult, EncounterMetadata metadata)
{
if (serverResult.IsError())
{
actionResult.SetError(serverResult.Exception);
return;
}
Debug.Log("Returned text from PHP: \n" + serverResult.Value);
if (string.IsNullOrWhiteSpace(serverResult.Value))
{
actionResult.SetError(new Exception("No text returned from the server."));
}
else if (!int.TryParse(serverResult.Value, out int recordNumber))
{
actionResult.SetError(new Exception(serverResult.Value));
}
else if (recordNumber != metadata.RecordNumber)
{
actionResult.SetError(new Exception("Did not get the correct metadata from the server."));
}
else
{
actionResult.SetCompleted();
}
}
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 virtual WaitableTask <UserEncounter> GetEncounter(User user, WaitableTask <IMenuEncountersInfo> encounters, int recordNumber)
{
var result = new WaitableTask <UserEncounter>();
encounters.AddOnCompletedListener((encountersResult) => SetUserEncounter(result, user, encountersResult, recordNumber));
return(result);
}
/**
* Downloads all available and applicable menu files to display on the main manu.
* Returns them as a MenuCase item
*/
public WaitableTask <string> Begin(UnityWebRequest webRequest)
{
var result = new WaitableTask <string>();
var requestOperation = webRequest.SendWebRequest();
requestOperation.completed += (asyncOperation) => ProcessWebrequest(webRequest, result);
return(result);
}
public WaitableTask <string[]> GetFilesText(User user, FileType fileType)
{
var filesText = new WaitableTask <string[]>();
var demoEncounters = GetDemoEncounters();
demoEncounters.AddOnCompletedListener((result) => ReadFiles(result, filesText, fileType));
return(filesText);
}
protected void ProcessResults(WaitableTask task, WaitableTask serverTask, WaitableTask localTask)
{
if (task.IsCompleted() || !serverTask.IsCompleted() || !localTask.IsCompleted())
{
return;
}
task.SetCompleted();
}
public void StartEncounter(User user, ILoadingScreen loadingScreen, WaitableTask <IMenuEncountersInfo> encounters, int recordNumber)
{
loadingScreen.Show();
ImageHolder.BeginHoldingData();
var encounter = GetEncounter(user, encounters, recordNumber);
var loadingSceneInfo = new LoadingReaderSceneInfo(user, loadingScreen, encounter);
SceneStarter.StartScene(loadingSceneInfo);
}
public WaitableTask <Dictionary <int, EncounterBasicStatus> > GetBasicStatuses(User user)
{
var statuses = new WaitableTask <Dictionary <int, EncounterBasicStatus> >();
var fileTexts = fileManager.GetFilesText(user, FileType.BasicStatus);
fileTexts.AddOnCompletedListener((result) => ProcessResults(statuses, result));
return(statuses);
}
public virtual WaitableTask UnlockEncounter(User user, EncounterMetadata metadata)
{
var webRequest = GetWebRequest(user, metadata);
var serverOutput = serverReader.Begin(webRequest);
var task = new WaitableTask();
serverOutput.AddOnCompletedListener((result) => ProcessResults(task, result));
return(task);
}
public WaitableTask <List <EncounterMetadata> > GetMetadatas(User user)
{
var metadatas = new WaitableTask <List <EncounterMetadata> >();
var fileTexts = fileManager.GetFilesText(user, FileType.Metadata);
fileTexts.AddOnCompletedListener((result) => ProcessResults(metadatas, result));
return(metadatas);
}
protected virtual WaitableTask <IMenuEncountersInfo> GetMenuEncountersInfo(
UserEncounter userEncounter)
{
var task = new WaitableTask <IMenuEncountersInfo>();
var categories = MenuInfoReader.GetMenuEncountersInfo(userEncounter.User);
categories.AddOnCompletedListener((result) =>
CompleteMenuEncountersInfoTask(task, result, userEncounter));
return(task);
}
public virtual WaitableTask <IMenuEncountersInfo> GetMenuEncountersInfo(User user)
{
var categories = new WaitableTask <IMenuEncountersInfo>();
var menuEncounters = menuEncountersReader.GetMenuEncounters(user);
menuEncounters.AddOnCompletedListener((result) => ProcessResults(user, categories, result));
return(categories);
}
public virtual WaitableTask <Dictionary <int, EncounterEditLock> > GetEncounterLocks(User user)
{
var webRequest = GetWebRequest(user);
var serverOutput = serverReader.Begin(webRequest);
var metadatas = new WaitableTask <Dictionary <int, EncounterEditLock> >();
serverOutput.AddOnCompletedListener((result) => ProcessResults(metadatas, result));
return(metadatas);
}
protected virtual void Initialize(object sender, WriterSceneInfoSelectedEventArgs e)
{
var sceneInfo = e.SceneInfo;
var encounterStatus = new EncounterStatus(new EncounterBasicStatus(), new EncounterContentStatus());
var encounter = new UserEncounter(sceneInfo.User, sceneInfo.Encounter, encounterStatus);
var encounterResult = new WaitableTask <UserEncounter>(encounter);
var loadingInfo = new LoadingReaderSceneInfo(sceneInfo.User, sceneInfo.LoadingScreen, encounterResult);
LoadingReaderSceneInfoSelector.Select(this, new LoadingReaderSceneInfoSelectedEventArgs(loadingInfo));
}
public WaitableTask <List <EncounterMetadata> > GetMetadatas(User user)
{
var webRequest = GetWebRequest(user);
var serverOutput = serverReader.Begin(webRequest);
var metadatas = new WaitableTask <List <EncounterMetadata> >();
serverOutput.AddOnCompletedListener((result) => ProcessResults(metadatas, result));
return(metadatas);
}
protected virtual void Apply()
{
if (LastUploadedIcon?.Reference != null && LastUploadedIcon != CurrentIcon)
{
Sprites.Remove(LastUploadedIcon.Reference);
}
CurrentIconTask.SetResult(CurrentIcon);
CurrentIconTask = null;
gameObject.SetActive(false);
}
private void CopyValue(TaskResult source, WaitableTask destination)
{
if (source.IsError())
{
destination.SetError(source.Exception);
}
else
{
destination.SetCompleted();
}
}
public virtual WaitableTask <User> Login()
{
var webRequest = GetWebRequest();
var serverResult = ServerReader.Begin(webRequest);
var user = new WaitableTask <User>();
serverResult.AddOnCompletedListener((result) => ProcessResults(user, result));
return(user);
}
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);
}
}
public override WaitableTask <Color> SelectColor(Color color)
{
CurrentColorTask?.SetError(new Exception("New popup opened"));
CurrentColorTask = new WaitableTask <Color>();
gameObject.SetActive(true);
colorEditor.Display(color);
return(CurrentColorTask);
}
protected virtual void SetFileResult(TaskResult <string> serverResult, WaitableTask <string> fileText)
{
if (serverResult.IsError())
{
fileText.SetError(serverResult.Exception);
}
else
{
fileText.SetResult(serverResult.Value);
}
}
public WaitableTask <string> GetFileText(User user, FileType fileType, EncounterMetadata metadata)
{
var fileText = new WaitableTask <string>();
var filePath = GetFile(fileType, metadata.Filename);
var webRequest = UnityWebRequest.Get(filePath);
var serverResult = serverReader.Begin(webRequest);
serverResult.AddOnCompletedListener((result) => SetFileResult(result, fileText));
return(fileText);
}
public WaitableTask <EncounterNonImageContent> GetNonImageContent(User user, EncounterMetadata metadata)
{
var contentData = new WaitableTask <EncounterNonImageContent>();
var webRequest = GetWebRequest(user, metadata);
var serverResult = serverReader.Begin(webRequest);
serverResult.AddOnCompletedListener((result) => ProcessResults(contentData, result));
return(contentData);
}
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);
}
public virtual WaitableTask <Sprite> SelectSprite(Sprite sprite)
{
if (CurrentWaitableSprite?.IsCompleted() == false)
{
CurrentWaitableSprite.SetError(new Exception("New popup opened"));
}
gameObject.SetActive(true);
SetImage(sprite);
CurrentWaitableSprite = new WaitableTask <Sprite>();
return(CurrentWaitableSprite);
}
public WaitableTask WriteStatus(UserEncounter encounter)
{
var task = new WaitableTask();
var serverTask = ServerStatusWriter.WriteStatus(encounter);
var localTask = LocalStatusWriter.WriteStatus(encounter);
serverTask.AddOnCompletedListener(ProcessTaskResults);
localTask.AddOnCompletedListener(ProcessTaskResults);
return(task);
void ProcessTaskResults(TaskResult taskResult) => ProcessResults(task, serverTask, localTask);
}
protected virtual void StartReader()
{
SceneInfoSelector.CurrentValue.SceneInfo.Encounter.Content.NonImageContent.SetCurrentSection(SectionSelector.CurrentValue.SelectedSection);
SectionSelector.CurrentValue.SelectedSection.SetCurrentTab(TabSelector.CurrentValue.SelectedTab);
SignalBus.Fire <SerializeEncounterSignal>();
var sceneInfo = SceneInfoSelector.CurrentValue.SceneInfo;
var encounterStatus = new EncounterStatus(new EncounterBasicStatus(), new EncounterContentStatus());
var encounter = new UserEncounter(sceneInfo.User, sceneInfo.Encounter, encounterStatus);
var encounterResult = new WaitableTask <UserEncounter>(encounter);
var loadingInfo = new LoadingReaderSceneInfo(sceneInfo.User, sceneInfo.LoadingScreen, encounterResult);
ReaderSceneStarter.StartScene(loadingInfo);
}
