/**
* <summary>Loads a new scene.</summary>
* <param name = "nextSceneInfo">Info about the scene to load</param>
* <param name = "sceneNumber">The number of the scene to load, if sceneName = ""</param>
* <param name = "saveRoomData">If True, then the states of the current scene's Remember scripts will be recorded in LevelStorage</param>
* <param name = "forceReload">If True, the scene will be re-loaded if it is already open.</param>
*/
public void ChangeScene(SceneInfo nextSceneInfo, bool saveRoomData, bool forceReload = false)
{
if (!isLoading)
{
PrepareSceneForExit (!KickStarter.settingsManager.useAsyncLoading, saveRoomData);
LoadLevel (nextSceneInfo, KickStarter.settingsManager.useLoadingScreen, KickStarter.settingsManager.useAsyncLoading, forceReload);
}
}
protected IEnumerator LoadLoadingScreen(int nextSceneIndex, int loadingSceneIndex, bool loadAsynchronously, bool doOverlay)
{
if (preloadSceneIndex >= 0)
{
ACDebug.LogWarning("Cannot use preloaded scene " + preloadSceneIndex + " because the loading scene overrides it - discarding preloaded data.");
}
preloadAsync = null;
preloadSceneIndex = -1;
isLoading = true;
loadingProgress = 0f;
SceneInfo loadingSceneInfo = GetSceneInfo(loadingSceneIndex);
if (loadingSceneInfo != null)
{
loadingSceneInfo.Open();
yield return(null);
if (KickStarter.player)
{
KickStarter.player.Teleport(KickStarter.player.Transform.position + new Vector3(0f, -10000f, 0f));
}
}
if (loadAsynchronously)
{
if (KickStarter.settingsManager.loadingDelay > 0f)
{
float waitForTime = Time.realtimeSinceStartup + KickStarter.settingsManager.loadingDelay;
while (Time.realtimeSinceStartup < waitForTime && KickStarter.settingsManager.loadingDelay > 0f)
{
yield return(null);
}
}
SceneInfo nextSceneInfo = GetSceneInfo(nextSceneIndex);
if (nextSceneInfo != null)
{
AsyncOperation aSync = nextSceneInfo.OpenAsync();
aSync.allowSceneActivation = false;
while (aSync.progress < 0.9f)
{
loadingProgress = aSync.progress;
yield return(null);
}
loadingProgress = 1f;
if (doOverlay)
{
yield return(new WaitForEndOfFrame());
KickStarter.mainCamera.TakeOverlayScreenshot();
}
if (KickStarter.settingsManager.manualSceneActivation)
{
if (KickStarter.eventManager)
{
completeSceneActivation = false;
KickStarter.eventManager.Call_OnAwaitSceneActivation(nextSceneIndex);
}
while (!completeSceneActivation)
{
yield return(null);
}
completeSceneActivation = false;
}
if (KickStarter.settingsManager.loadingDelay > 0f)
{
float waitForTime = Time.realtimeSinceStartup + KickStarter.settingsManager.loadingDelay;
while (Time.realtimeSinceStartup < waitForTime && KickStarter.settingsManager.loadingDelay > 0f)
{
yield return(null);
}
}
aSync.allowSceneActivation = true;
KickStarter.stateHandler.IgnoreNavMeshCollisions();
}
}
else
{
SceneInfo nextSceneInfo = GetSceneInfo(nextSceneIndex);
if (nextSceneInfo != null)
{
nextSceneInfo.Open();
}
else
{
isLoading = false;
}
}
}
protected IEnumerator LoadLevelAsync(SceneInfo nextSceneInfo)
{
isLoading = true;
loadingProgress = 0f;
PrepareSceneForExit(true, false);
AsyncOperation aSync = null;
if (nextSceneInfo.Matches(preloadSceneInfo))
{
aSync = preloadAsync;
aSync.allowSceneActivation = true;
while (!aSync.isDone)
{
loadingProgress = aSync.progress;
yield return(null);
}
loadingProgress = 1f;
}
else
{
aSync = nextSceneInfo.LoadLevelASync();
aSync.allowSceneActivation = false;
while (aSync.progress < 0.9f)
{
loadingProgress = aSync.progress;
yield return(null);
}
loadingProgress = 1f;
isLoading = false;
if (KickStarter.settingsManager.manualSceneActivation)
{
if (KickStarter.eventManager != null)
{
completeSceneActivation = false;
KickStarter.eventManager.Call_OnAwaitSceneActivation(nextSceneInfo);
}
while (!completeSceneActivation)
{
yield return(null);
}
completeSceneActivation = false;
}
yield return(new WaitForEndOfFrame());
aSync.allowSceneActivation = true;
}
KickStarter.stateHandler.IgnoreNavMeshCollisions();
isLoading = false;
preloadAsync = null;
preloadSceneInfo = new SceneInfo(string.Empty, -1);
StartCoroutine(OnCompleteSceneChange());
}
private void ChangeScene()
{
if (sceneNumber > -1 || chooseSceneBy == ChooseSceneBy.Name)
{
SceneInfo sceneInfo = new SceneInfo (chooseSceneBy, sceneName, sceneNumber);
if (!onlyPreload && relativePosition && relativeMarker != null)
{
KickStarter.sceneChanger.SetRelativePosition (relativeMarker.transform);
}
if (onlyPreload)
{
if (AdvGame.GetReferences ().settingsManager.useAsyncLoading)
{
KickStarter.sceneChanger.PreloadScene (sceneInfo);
}
else
{
ACDebug.LogWarning ("To pre-load scenes, 'Load scenes asynchronously?' must be enabled in the Settings Manager.");
}
}
else
{
KickStarter.sceneChanger.ChangeScene (sceneInfo, true);
}
}
}
private IEnumerator LoadLevelCo(SceneInfo nextSceneInfo, bool forceReload = false)
{
isLoading = true;
yield return new WaitForEndOfFrame ();
nextSceneInfo.LoadLevel (forceReload);
isLoading = false;
}
private IEnumerator LoadLoadingScreen(SceneInfo nextSceneInfo, SceneInfo loadingSceneInfo, bool loadAsynchronously = false)
{
isLoading = true;
loadingProgress = 0f;
loadingSceneInfo.LoadLevel();
yield return(null);
if (KickStarter.player != null)
{
KickStarter.player.transform.position += new Vector3(0f, -10000f, 0f);
}
PrepareSceneForExit(true, false);
if (loadAsynchronously)
{
if (KickStarter.settingsManager.loadingDelay > 0f)
{
float waitForTime = Time.realtimeSinceStartup + KickStarter.settingsManager.loadingDelay;
while (Time.realtimeSinceStartup < waitForTime)
{
yield return(null);
}
}
AsyncOperation aSync = null;
if (nextSceneInfo.Matches(preloadSceneInfo))
{
aSync = preloadAsync;
}
else
{
aSync = nextSceneInfo.LoadLevelASync();
}
if (KickStarter.settingsManager.loadingDelay > 0f)
{
aSync.allowSceneActivation = false;
while (aSync.progress < 0.9f)
{
loadingProgress = aSync.progress;
yield return(null);
}
isLoading = false;
if (KickStarter.settingsManager.loadingDelay > 0f)
{
float waitForTime = Time.realtimeSinceStartup + KickStarter.settingsManager.loadingDelay;
while (Time.realtimeSinceStartup < waitForTime)
{
yield return(null);
}
}
aSync.allowSceneActivation = true;
}
else
{
while (!aSync.isDone)
{
loadingProgress = aSync.progress;
yield return(null);
}
}
KickStarter.stateHandler.GatherObjects();
}
else
{
nextSceneInfo.LoadLevel();
}
isLoading = false;
preloadAsync = null;
preloadSceneInfo = new SceneInfo("", -1);
if (KickStarter.eventManager != null)
{
KickStarter.eventManager.Call_OnAfterChangeScene();
}
}
override public float Run ()
{
SceneInfo sceneInfo = new SceneInfo (chooseSceneBy, AdvGame.ConvertTokens (sceneName), sceneNumber);
if (!isRunning)
{
waitedOneMoreFrame = false;
isRunning = true;
if (KickStarter.sceneSettings.OverridesCameraPerspective ())
{
ACDebug.LogError ("The current scene overrides the default camera perspective - this feature should not be used in conjunction with multiple-open scenes.");
}
if (sceneAddRemove == SceneAddRemove.Add)
{
if (KickStarter.sceneChanger.AddSubScene (sceneInfo))
{
return defaultPauseTime;
}
}
else if (sceneAddRemove == SceneAddRemove.Remove)
{
KickStarter.sceneChanger.RemoveScene (sceneInfo);
}
}
else
{
if (!waitedOneMoreFrame)
{
waitedOneMoreFrame = true;
return defaultPauseTime;
}
if (sceneAddRemove == SceneAddRemove.Add)
{
bool found = false;
foreach (SubScene subScene in KickStarter.sceneChanger.GetSubScenes ())
{
if (subScene.SceneInfo.Matches (sceneInfo))
{
found = true;
if (runCutsceneOnStart && subScene.SceneSettings != null && subScene.SceneSettings.cutsceneOnStart != null)
{
subScene.SceneSettings.cutsceneOnStart.Interact ();
}
}
}
if (!found)
{
ACDebug.LogWarning ("Adding a non-AC scene additively! A GameEngine prefab must be placed in scene '" + sceneInfo.GetLabel () + "'.");
}
}
isRunning = false;
}
return 0f;
}
public void PreloadScene(SceneInfo nextSceneInfo)
{
StartCoroutine(PreloadLevelAsync(nextSceneInfo));
}
private IEnumerator LoadLevel(SceneInfo nextSceneInfo)
{
isLoading = true;
yield return new WaitForEndOfFrame ();
nextSceneInfo.LoadLevel ();
isLoading = false;
}
private void LoadLevel(SceneInfo nextSceneInfo, bool useLoadingScreen, bool useAsyncLoading)
{
if (useLoadingScreen)
{
StartCoroutine (LoadLoadingScreen (nextSceneInfo, new SceneInfo (KickStarter.settingsManager.loadingSceneIs, KickStarter.settingsManager.loadingSceneName, KickStarter.settingsManager.loadingScene), useAsyncLoading));
}
else
{
if (useAsyncLoading)
{
StartCoroutine (LoadLevelAsync (nextSceneInfo));
}
else
{
StartCoroutine (LoadLevel (nextSceneInfo));
}
}
}
private void Awake()
{
previousSceneInfo = new SceneInfo ("", -1);
relativePosition = Vector3.zero;
isLoading = false;
}
public void PreloadScene(SceneInfo nextSceneInfo)
{
StartCoroutine (PreloadLevelAsync (nextSceneInfo));
}
/**
* <summary>Checks if the variables in this instance of the class match another instance.</summary>
* <param name = "_sceneInfo">The other SceneInfo instance to compare</param>
* <returns>True if the variables in this instance of the class matches the other instance</returns>
*/
public bool Matches(SceneInfo _sceneInfo)
{
if (name == _sceneInfo.name && number == _sceneInfo.number)
{
return true;
}
return false;
}
private void PrepareSceneForExit(bool isInstant, bool saveRoomData)
{
if (isInstant)
{
KickStarter.mainCamera.FadeOut (0f);
if (KickStarter.player)
{
KickStarter.player.Halt ();
}
KickStarter.stateHandler.gameState = GameState.Normal;
}
Sound[] sounds = FindObjectsOfType (typeof (Sound)) as Sound[];
foreach (Sound sound in sounds)
{
sound.TryDestroy ();
}
KickStarter.stateHandler.GatherObjects ();
KickStarter.playerMenus.ClearParents ();
if (KickStarter.dialog)
{
KickStarter.dialog.KillDialog (true, true);
}
if (saveRoomData)
{
KickStarter.levelStorage.StoreCurrentLevelData ();
previousSceneInfo = new SceneInfo ();
}
playerOnTransition = KickStarter.player;
}
protected IEnumerator LoadLevelAsync(int nextSceneIndex, bool doOverlay)
{
if (nextSceneIndex >= 0)
{
isLoading = true;
loadingProgress = 0f;
AsyncOperation aSync = null;
if (nextSceneIndex == preloadSceneIndex)
{
aSync = preloadAsync;
aSync.allowSceneActivation = true;
while (!aSync.isDone)
{
loadingProgress = aSync.progress;
yield return(null);
}
loadingProgress = 1f;
}
else
{
SceneInfo nextSceneInfo = GetSceneInfo(nextSceneIndex);
if (nextSceneInfo != null)
{
aSync = nextSceneInfo.OpenAsync();
if (aSync != null)
{
aSync.allowSceneActivation = false;
while (aSync.progress < 0.9f)
{
loadingProgress = aSync.progress;
yield return(null);
}
loadingProgress = 1f;
//isLoading = false;
if (doOverlay)
{
yield return(new WaitForEndOfFrame());
KickStarter.mainCamera.TakeOverlayScreenshot();
}
if (KickStarter.settingsManager.manualSceneActivation)
{
if (KickStarter.eventManager)
{
completeSceneActivation = false;
KickStarter.eventManager.Call_OnAwaitSceneActivation(nextSceneIndex);
}
while (!completeSceneActivation)
{
yield return(null);
}
completeSceneActivation = false;
}
yield return(new WaitForEndOfFrame());
aSync.allowSceneActivation = true;
}
else
{
isLoading = false;
}
}
}
KickStarter.stateHandler.IgnoreNavMeshCollisions();
//isLoading = false;
preloadAsync = null;
preloadSceneIndex = -1;
}
}
private IEnumerator LoadLevelAsync(SceneInfo nextSceneInfo)
{
isLoading = true;
loadingProgress = 0f;
PrepareSceneForExit (true, false);
AsyncOperation aSync = null;
if (nextSceneInfo.Matches (preloadSceneInfo))
{
aSync = preloadAsync;
aSync.allowSceneActivation = true;
}
else
{
aSync = nextSceneInfo.LoadLevelASync ();
}
while (!aSync.isDone)
{
loadingProgress = aSync.progress;
yield return null;
}
KickStarter.stateHandler.GatherObjects ();
isLoading = false;
preloadAsync = null;
preloadSceneInfo = new SceneInfo ("", -1);
}
/**
* <summary>Checks if this class instance represetnts the currently-active main scene</summary>
* <returns>True if this class instance represetnts the currently-active main scene</returns>
*/
public bool IsCurrentActive()
{
SceneInfo activeSceneInfo = new SceneInfo(UnityVersionHandler.GetCurrentSceneName(), UnityVersionHandler.GetCurrentSceneNumber());
return(Matches(activeSceneInfo));
}
private IEnumerator LoadLoadingScreen(SceneInfo nextSceneInfo, SceneInfo loadingSceneInfo, bool loadAsynchronously = false)
{
isLoading = true;
loadingProgress = 0f;
if (KickStarter.player != null)
{
KickStarter.player.transform.position += new Vector3 (0f, -10000f, 0f);
}
loadingSceneInfo.LoadLevel ();
yield return null;
PrepareSceneForExit (true, false);
if (loadAsynchronously)
{
yield return new WaitForSeconds (KickStarter.settingsManager.loadingDelay);
AsyncOperation aSync = null;
if (nextSceneInfo.Matches (preloadSceneInfo))
{
aSync = preloadAsync;
}
else
{
aSync = nextSceneInfo.LoadLevelASync ();
}
if (KickStarter.settingsManager.loadingDelay > 0f)
{
aSync.allowSceneActivation = false;
while (aSync.progress < 0.9f)
{
loadingProgress = aSync.progress;
yield return null;
}
isLoading = false;
yield return new WaitForSeconds (KickStarter.settingsManager.loadingDelay);
aSync.allowSceneActivation = true;
}
else
{
while (!aSync.isDone)
{
loadingProgress = aSync.progress;
yield return null;
}
}
KickStarter.stateHandler.GatherObjects ();
}
else
{
nextSceneInfo.LoadLevel ();
}
isLoading = false;
preloadAsync = null;
preloadSceneInfo = new SceneInfo ("", -1);
}
public void OnAwake()
{
previousSceneInfo = new SceneInfo("", -1);
relativePosition = Vector3.zero;
isLoading = false;
}
private IEnumerator PreloadLevelAsync(SceneInfo nextSceneInfo)
{
loadingProgress = 0f;
preloadSceneInfo = nextSceneInfo;
preloadAsync = nextSceneInfo.LoadLevelASync ();
preloadAsync.allowSceneActivation = false;
// Wait until done and collect progress as we go.
while (!preloadAsync.isDone)
{
loadingProgress = preloadAsync.progress;
if (loadingProgress >= 0.9f)
{
// Almost done.
break;
}
yield return null;
}
}
private IEnumerator LoadLoadingScreen(SceneInfo nextSceneInfo, SceneInfo loadingSceneInfo, bool loadAsynchronously = false)
{
if (preloadSceneInfo != null && !preloadSceneInfo.IsNull)
{
ACDebug.LogWarning("Cannot use preloaded scene '" + preloadSceneInfo.GetLabel() + "' because the loading scene overrides it - discarding preloaded data.");
}
preloadAsync = null;
preloadSceneInfo = new SceneInfo("", -1);
isLoading = true;
loadingProgress = 0f;
loadingSceneInfo.LoadLevel();
yield return(null);
if (KickStarter.player != null)
{
KickStarter.player.transform.position += new Vector3(0f, -10000f, 0f);
}
PrepareSceneForExit(true, false);
if (loadAsynchronously)
{
if (KickStarter.settingsManager.loadingDelay > 0f)
{
float waitForTime = Time.realtimeSinceStartup + KickStarter.settingsManager.loadingDelay;
while (Time.realtimeSinceStartup < waitForTime && KickStarter.settingsManager.loadingDelay > 0f)
{
yield return(null);
}
}
AsyncOperation aSync = nextSceneInfo.LoadLevelASync();
if (KickStarter.settingsManager.loadingDelay > 0f)
{
aSync.allowSceneActivation = false;
while (aSync.progress < 0.9f)
{
loadingProgress = aSync.progress;
yield return(null);
}
isLoading = false;
float waitForTime = Time.realtimeSinceStartup + KickStarter.settingsManager.loadingDelay;
while (Time.realtimeSinceStartup < waitForTime && KickStarter.settingsManager.loadingDelay > 0f)
{
yield return(null);
}
aSync.allowSceneActivation = true;
}
else
{
while (!aSync.isDone)
{
loadingProgress = aSync.progress;
yield return(null);
}
}
KickStarter.stateHandler.IgnoreNavMeshCollisions();
}
else
{
nextSceneInfo.LoadLevel();
}
isLoading = false;
StartCoroutine(OnCompleteSceneChange());
}
private void PrepareSceneForExit(bool isInstant, bool saveRoomData)
{
if (isInstant)
{
KickStarter.mainCamera.FadeOut (0f);
if (KickStarter.player)
{
KickStarter.player.Halt ();
if (KickStarter.settingsManager.movementMethod == MovementMethod.UltimateFPS)
{
UltimateFPSIntegration.SetCameraEnabled (false, true);
}
}
KickStarter.stateHandler.gameState = GameState.Normal;
}
Sound[] sounds = FindObjectsOfType (typeof (Sound)) as Sound[];
foreach (Sound sound in sounds)
{
sound.TryDestroy ();
}
KickStarter.stateHandler.GatherObjects ();
KickStarter.playerMenus.ClearParents ();
if (KickStarter.dialog)
{
KickStarter.dialog.KillDialog (true, true);
}
if (saveRoomData)
{
KickStarter.levelStorage.StoreCurrentLevelData ();
previousSceneInfo = new SceneInfo (Application.loadedLevelName, Application.loadedLevel);
}
playerOnTransition = KickStarter.player;
}
private void AssignThisSceneInfo()
{
thisSceneInfo = new SceneInfo(UnityVersionHandler.GetCurrentSceneName(), UnityVersionHandler.GetCurrentSceneNumber());
}
/**
* <summary>Creates a new instance of the 'Player: Switch' Action, set to make the old Player become an NPC</summary>
* <param name = "newPlayerID">The ID number of the Player to switch to</param>
* <param name = "transferInventory">If True, the previous Player's inventory will be transferred to the new one</param>
* <param name = "newSceneInfo">A data container for information about the new Player's scene. If null, the new Player will replace his associated NPC in the current scene</param>
* <returns>The generated Action</returns>
*/
public static ActionPlayerSwitch CreateNew (int newPlayerID, bool transferInventory = false, SceneInfo newSceneInfo = null)
{
ActionPlayerSwitch newAction = (ActionPlayerSwitch) CreateInstance <ActionPlayerSwitch>();
newAction.playerID = newPlayerID;
newAction.restorePreviousData = true;
newAction.keepInventory = transferInventory;
newAction.newPlayerPosition = (newSceneInfo != null) ? NewPlayerPosition.AppearInOtherScene : NewPlayerPosition.ReplaceAssociatedNPC;
newAction.oldPlayer = OldPlayer.ReplaceWithAssociatedNPC;
if (newSceneInfo != null)
{
newAction.newPlayerScene = newSceneInfo.number;
newAction.newPlayerSceneName = newSceneInfo.name;
}
return newAction;
}
