private static void FinishMovingToLoadedScene(ILoadableGameState newScene, Save save)
{
newScene.IsLoadedFromSave = true;
SceneManager.Instance.SwitchToScene(newScene.GameStateRoot);
newScene.OnFinishLoading(save);
}
private void Step()
{
switch (state)
{
case State.Initial:
state = State.ReadingData;
// Invalid is given as the target state here, because it's unknown yet.
// TODO: See #1847
LoadingScreen.Instance.Show(TranslationServer.Translate("LOADING_GAME"),
MainGameState.Invalid,
TranslationServer.Translate("READING_SAVE_DATA"));
// Let all suppressed deletions happen
TemporaryLoadedNodeDeleter.Instance.ReleaseAllHolds();
break;
case State.ReadingData:
{
// Start suppressing loaded node deletion
TemporaryLoadedNodeDeleter.Instance.AddDeletionHold(Constants.DELETION_HOLD_LOAD);
// TODO: do this in a background thread if possible
try
{
// Invalid is given as the target state here, because it's unknown yet.
// TODO: See #1847
save = Save.LoadFromFile(saveName, () => Invoke.Instance.Perform(() =>
LoadingScreen.Instance.Show(TranslationServer.Translate("LOADING_GAME"),
MainGameState.Invalid,
TranslationServer.Translate("CREATING_OBJECTS_FROM_SAVE"))));
state = State.CreatingScene;
}
catch (Exception e)
{
ReportStatus(false,
TranslationServer.Translate("AN_EXCEPTION_HAPPENED_WHILE_LOADING"),
e.ToString());
state = State.Finished;
// ReSharper disable HeuristicUnreachableCode ConditionIsAlwaysTrueOrFalse
if (!Constants.CATCH_SAVE_ERRORS)
#pragma warning disable 162
{
throw;
}
#pragma warning restore 162
// ReSharper restore HeuristicUnreachableCode ConditionIsAlwaysTrueOrFalse
}
break;
}
case State.CreatingScene:
{
try
{
loadedState = save.TargetScene;
}
catch (Exception)
{
ReportStatus(false, TranslationServer.Translate("SAVE_IS_INVALID"),
TranslationServer.Translate("SAVE_HAS_INVALID_GAME_STATE"));
state = State.Finished;
break;
}
state = State.ProcessingLoadedObjects;
break;
}
case State.ProcessingLoadedObjects:
{
LoadingScreen.Instance.Show(TranslationServer.Translate("LOADING_GAME"),
save.GameState,
TranslationServer.Translate("PROCESSING_LOADED_OBJECTS"));
if (loadedState.IsLoadedFromSave != true)
{
throw new Exception("Game load logic not working correctly, IsLoadedFromSave was not set");
}
try
{
SceneManager.Instance.SwitchToScene(loadedState.GameStateRoot);
loadedState.OnFinishLoading(save);
}
catch (Exception e)
{
ReportStatus(false,
TranslationServer.Translate("AN_EXCEPTION_HAPPENED_WHILE_PROCESSING"),
e.ToString());
state = State.Finished;
break;
}
ReportStatus(true, TranslationServer.Translate("LOAD_FINISHED"), string.Empty);
state = State.Finished;
break;
}
case State.Finished:
{
stopwatch.Stop();
GD.Print("load finished, success: ", success, " message: ", message, " elapsed: ", stopwatch.Elapsed);
// Stop suppressing loaded node deletion
TemporaryLoadedNodeDeleter.Instance.RemoveDeletionHold(Constants.DELETION_HOLD_LOAD);
if (success)
{
LoadingScreen.Instance.Hide();
SaveStatusOverlay.Instance.ShowMessage(message);
// TODO: does this cause problems if the game was paused when saving?
loadedState.GameStateRoot.GetTree().Paused = false;
}
else
{
SaveStatusOverlay.Instance.ShowError(TranslationServer.Translate("ERROR_LOADING"),
message, exception, true,
() => LoadingScreen.Instance.Hide());
}
IsLoading = false;
return;
}
default:
throw new InvalidOperationException();
}
Invoke.Instance.Queue(Step);
}
private void Step()
{
switch (state)
{
case State.Initial:
state = State.ReadingData;
LoadingScreen.Instance.Show("Loading Game", "Reading save data");
// Start suppressing loaded node deletion
TemporaryLoadedNodeDeleter.Instance.AddDeletionHold(Constants.DELETION_HOLD_LOAD);
break;
case State.ReadingData:
{
// TODO: do this in a background thread if possible
try
{
save = Save.LoadFromFile(saveName, () => Invoke.Instance.Perform(() =>
LoadingScreen.Instance.Show("Loading Game", "Creating objects from save")));
}
catch (Exception e)
{
ReportStatus(false, "An exception happened while loading the save data", e.ToString());
state = State.Finished;
break;
}
state = State.CreatingScene;
break;
}
case State.CreatingScene:
{
try
{
loadedScene = SceneManager.Instance.LoadScene(save.GameState);
}
catch (ArgumentException)
{
ReportStatus(false, "Save is invalid", "Save has an unknown game state");
state = State.Finished;
break;
}
try
{
loadedState = (ILoadableGameState)loadedScene.Instance();
}
catch (Exception e)
{
ReportStatus(false, "An exception happened while instantiating target scene", e.ToString());
state = State.Finished;
break;
}
state = State.ProcessingLoadedObjects;
break;
}
case State.ProcessingLoadedObjects:
{
LoadingScreen.Instance.Show("Loading Game", "Processing loaded objects");
loadedState.IsLoadedFromSave = true;
SceneManager.Instance.SwitchToScene(loadedState.GameStateRoot);
try
{
loadedState.OnFinishLoading(save);
}
catch (Exception e)
{
ReportStatus(false, "An exception happened while processing loaded objects", e.ToString());
state = State.Finished;
break;
}
ReportStatus(true, "Load finished", string.Empty);
state = State.Finished;
break;
}
case State.Finished:
{
stopwatch.Stop();
GD.Print("load finished, success: ", success, " message: ", message, " elapsed: ", stopwatch.Elapsed);
// Stop suppressing loaded node deletion
TemporaryLoadedNodeDeleter.Instance.RemoveDeletionHold(Constants.DELETION_HOLD_LOAD);
if (success)
{
LoadingScreen.Instance.Hide();
SaveStatusOverlay.Instance.ShowMessage(message);
loadedState.GameStateRoot.GetTree().Paused = false;
}
else
{
SaveStatusOverlay.Instance.ShowError("Error Loading", message, exception, true,
() => LoadingScreen.Instance.Hide());
}
return;
}
default:
throw new InvalidOperationException();
}
Invoke.Instance.Queue(Step);
}
private void Step()
{
switch (state)
{
case State.Initial:
state = State.ReadingData;
LoadingScreen.Instance.Show("Loading Game", "Reading save data");
// Let all suppressed deletions happen
TemporaryLoadedNodeDeleter.Instance.ReleaseAllHolds();
break;
case State.ReadingData:
{
// Start suppressing loaded node deletion
TemporaryLoadedNodeDeleter.Instance.AddDeletionHold(Constants.DELETION_HOLD_LOAD);
// TODO: do this in a background thread if possible
try
{
save = Save.LoadFromFile(saveName, () => Invoke.Instance.Perform(() =>
LoadingScreen.Instance.Show("Loading Game", "Creating objects from save")));
state = State.CreatingScene;
}
catch (Exception e)
{
ReportStatus(false, "An exception happened while loading the save data", e.ToString());
state = State.Finished;
// ReSharper disable HeuristicUnreachableCode ConditionIsAlwaysTrueOrFalse
if (!Constants.CATCH_SAVE_ERRORS)
#pragma warning disable 162
{
throw;
}
#pragma warning restore 162
// ReSharper restore HeuristicUnreachableCode ConditionIsAlwaysTrueOrFalse
}
break;
}
case State.CreatingScene:
{
try
{
loadedState = save.TargetScene;
}
catch (Exception)
{
ReportStatus(false, "Save is invalid", "Save has invalid game state scene");
state = State.Finished;
break;
}
state = State.ProcessingLoadedObjects;
break;
}
case State.ProcessingLoadedObjects:
{
LoadingScreen.Instance.Show("Loading Game", "Processing loaded objects");
if (loadedState.IsLoadedFromSave != true)
{
throw new Exception("Game load logic not working correctly, IsLoadedFromSave was not set");
}
try
{
SceneManager.Instance.SwitchToScene(loadedState.GameStateRoot);
loadedState.OnFinishLoading(save);
}
catch (Exception e)
{
ReportStatus(false, "An exception happened while processing loaded objects", e.ToString());
state = State.Finished;
break;
}
ReportStatus(true, "Load finished", string.Empty);
state = State.Finished;
break;
}
case State.Finished:
{
stopwatch.Stop();
GD.Print("load finished, success: ", success, " message: ", message, " elapsed: ", stopwatch.Elapsed);
// Stop suppressing loaded node deletion
TemporaryLoadedNodeDeleter.Instance.RemoveDeletionHold(Constants.DELETION_HOLD_LOAD);
if (success)
{
LoadingScreen.Instance.Hide();
SaveStatusOverlay.Instance.ShowMessage(message);
// TODO: does this cause problems if the game was paused when saving?
loadedState.GameStateRoot.GetTree().Paused = false;
}
else
{
SaveStatusOverlay.Instance.ShowError("Error Loading", message, exception, true,
() => LoadingScreen.Instance.Hide());
}
IsLoading = false;
return;
}
default:
throw new InvalidOperationException();
}
Invoke.Instance.Queue(Step);
}
