bool test = false; //Controlar o carregamento da cena. #endregion Fields #region Methods /*A coroutine abaixo descreve a loading screen, seus objetos sao ativados, o texto que se trata da porcentagem se torna * equivalente ao objeto progressbar que cresce durante o carregamento da cena. Caso o mesmo carregamento esteja completo * a proxima cena sera carregada*/ IEnumerator DisplayLoadScreen() { background.SetActive (true); text1.renderer.enabled = true; progressbar.SetActive (true); progressbar.transform.localScale = new Vector3 (progressbar.transform.localScale.x, progressbar.transform.localScale.y, LoadProgress); text1.text = LoadProgress + "%"; async = Application.LoadLevelAsync (2); while (!async.isDone) { LoadProgress = (int)(async.progress * 110); text1.text = LoadProgress + "%"; progressbar.transform.localScale = new Vector3 (progressbar.transform.localScale.x, progressbar.transform.localScale.y, async.progress); yield return null; } }
public void Show(AsyncOperation ao) { gameObject.SetActive(true); bg.SetActive(true); isAsyn = true; this.ao = ao; }
// Use this for initialization void Start () { #if UNITY_5_3 async = SceneManager.LoadSceneAsync(GlobalData.NextLevel); #else async =Application.LoadLevelAsync(GlobalData.NextLevel); #endif }
public IEnumerator LoadScene(string SceneName) { _mCameraGameObject.SetActive(true); async = Application.LoadLevelAsync(SceneName); async.allowSceneActivation = false; yield return async; }
IEnumerator Load() { switch(GameData.Instance.CurrentLevel) { case Levels.Level_1: switch(GameData.Instance.CurrentSection) { case Sections.Sections_1: m_Async = Application.LoadLevelAsync(Constants.LEVEL1_SECTION1); break; case Sections.Sections_2: m_Async = Application.LoadLevelAsync(Constants.LEVEL1_SECTION2); break; case Sections.Sections_3: m_Async = Application.LoadLevelAsync(Constants.LEVEL1_SECTION3); break; } break; } // m_Async.allowSceneActivation = false; yield return m_Async.isDone; yield return SwitchScene(); }
void Start() { async = Application.LoadLevelAsync(5); async.allowSceneActivation = false; //yield return async; Debug.Log("Loading complete"); }
public static IEnumerator LoadLevelSCREEN(string name) { rnging = true; async = Application.LoadLevelAsync(name); yield return async; }
public void changeScene(string nextScene) { //Application.LoadLevel(nextScene); preloaderScreen.SetActive (true); loadOp = Application.LoadLevelAsync(nextScene); StartCoroutine (ScenePreload ()); }
public void Start() { if (this.SyncRequest == null) { this.SyncRequest = Res.LoadAsync(this.resourcePath, this.resourceType); } }
copyrightVisible = false; //determines if copyright is visible #endregion Fields #region Methods //Loads the next scene. IEnumerator AsyncLoadLevel() { async = Application.LoadLevelAsync("Greenlight Screen"); async.allowSceneActivation = false; yield return async; Debug.Log("Loading complete"); }
IEnumerator load() { Debug.LogWarning("ASYNC LOAD STARTED - " + "DO NOT EXIT PLAY MODE UNTIL SCENE LOADS... UNITY WILL CRASH"); async = Application.LoadLevelAsync(sceneToLoad.ToString()); async.allowSceneActivation = false; yield return async; }
IEnumerator LoadScene() { processBar.gameObject.SetActive(true); async = Application.LoadLevelAsync("Main"); async.allowSceneActivation = false; yield return async; }
public void show(AsyncOperation ao) { Debug.Log("ao.progress: " + ao.progress); gameObject.SetActive(true); bg.SetActive(true); progressBar.value = ao.progress; }
IEnumerator Workflow() { FadeIn fadeIn = logo.AddComponent<FadeIn>(); fadeIn.time = 1.0f; fadeIn.Begin(); yield return new WaitForSeconds(2f); FadeOut fadeOut = logo.AddComponent<FadeOut>(); fadeOut.time = 1.0f; fadeOut.Begin(); yield return new WaitForSeconds(1f); logo.SetActive(false); loadingLayer.SetActive(true); yield return new WaitForEndOfFrame(); MoveBy move = title.AddComponent<MoveBy>(); move.offset = new Vector3(0, -2f, 0); move.time = 1f; move.Begin(); yield return new WaitForSeconds(1f); async = Application.LoadLevelAsync("MainScene"); async.allowSceneActivation = false; yield return StartCoroutine(Loading()); text.text = "开始游戏"; button.enabled = true; }
private IEnumerator LoadLevel(int iSceneIndex) { m_LabelProg.gameObject.SetActive(true); m_Asyn = SceneManager.LoadSceneAsync (iSceneIndex); yield return m_Asyn; }
IEnumerator LoadNextLevel() { async = Application.LoadLevelAsync(1); async.allowSceneActivation = false; yield return async; }
public void GoToLevelScene() { GameStateManager.setGameState (GameState.Playing); a = Application.LoadLevelAsync ("LevelScene"); //a.allowSceneActivation = false; timeStartLoading = Time.time; }
public void OperationShouldSerializeAsyncMethodWithViewModel() { var vmMock = new NavigableViewModelMock(); ServiceProvider.OperationCallbackFactory = new SerializableOperationCallbackFactory(); var operation = new AsyncOperation<bool>(); IOperationResult<bool> result = OperationResult.CreateResult(OperationType.PageNavigation, this, true, new NavigationContext(NavigationType.Page, NavigationMode.Back, vmMock, vmMock, this)); AsyncMethodWithViewModel(operation, true, vmMock); var callback = operation.ToOperationCallback(); var serialize = Serializer.Serialize(callback); serialize.Position = 0; callback = (IOperationCallback)Serializer.Deserialize(serialize); IocContainer.GetFunc = (type, s, arg3) => { if (type == GetType()) return this; return Activator.CreateInstance(type); }; AsyncMethodInvoked.ShouldBeFalse(); ViewModel.ShouldBeNull(); callback.Invoke(result); AsyncMethodInvoked.ShouldBeTrue(); ViewModel.ShouldEqual(vmMock); }
void FixedUpdate() { if (Input.GetButton("Jump")) { Debug.Log("Load..."); if (loadscene != null) { if (loadscene.progress >= 0.9f) loadscene.allowSceneActivation = true; } //SceneManager.LoadScene("sceneB"); //SceneManager.MoveGameObjectToScene(moveobject,SceneManager.GetSceneByName("sceneB")); //StartCoroutine(Example()); } else if (Input.GetKeyDown(KeyCode.A)) { Debug.Log("Load Async..."); loadscene = SceneManager.LoadSceneAsync("sceneB",LoadSceneMode.Additive); loadscene.allowSceneActivation = false; //SceneManager.MoveGameObjectToScene(moveobject, SceneManager.GetSceneByName("sceneB")); //StartCoroutine(Example()); } else if (Input.GetKeyDown(KeyCode.M)) { Debug.Log("Merge..."); SceneManager.MergeScenes(SceneManager.GetSceneByName("sceneA"), SceneManager.GetSceneByName("sceneB")); //StartCoroutine(Example()); } else if (Input.GetKeyDown(KeyCode.U)) { if (SceneManager.GetSceneByName("SceneB").isLoaded) { SceneManager.UnloadScene("SceneB"); } } }
IEnumerator Start () { if(MenuControllerGenerator.controller) { unloadUnusedAssets = Resources.UnloadUnusedAssets(); StartCoroutine("UpdateLoader"); yield return unloadUnusedAssets; StopCoroutine("UpdateLoader"); MenuControllerGenerator.controller.LoaderIsDoneUnload = true; MenuControllerGenerator.controller.progress = 0.2f; yield return new WaitForEndOfFrame(); if(MenuControllerGenerator.controller.levelName != "") Application.LoadLevel(MenuControllerGenerator.controller.levelName); else Application.LoadLevel(MenuControllerGenerator.controller.levelNumber); } else { yield return null; #if UNITY_EDITOR if(Application.levelCount >= 3) Application.LoadLevel("GameStart"); else Debug.LogError("Please add the scenes (GameStart, Game and Loader) in the File/Build Settings" + " as shown in the image Assets/BallPool/TagAndLayers.png"); #endif } }
IEnumerator LoadCurrentScene()//try again { yield return new WaitForSeconds(1); //asyn = Application.LoadLevelAsync ("level3"); asyn = Application.LoadLevelAsync ("level9"); yield return new WaitForSeconds(1); }
IEnumerator loadScene() { async = Application.LoadLevelAsync (Globe.getInstance().loadName); async.allowSceneActivation = false; while(async.progress<0.9f) { per+=0.01f; text.text =Mathf.Floor( per*100)+"%"; loadingMc.fillAmount = per; yield return new WaitForEndOfFrame(); } while (per <1f) { per+=0.01f; text.text =Mathf.Floor( per*100)+"%"; loadingMc.fillAmount = per; yield return new WaitForEndOfFrame(); } if(Globe.getInstance().afterEnterWorldHandler!=null) { Globe.getInstance().afterEnterWorldHandler(); Globe.getInstance().afterEnterWorldHandler=null; } async.allowSceneActivation = true; }
public void ContinueWithActionInterfaceToOperationCallbackTest() { var operation = new AsyncOperation<bool>(); IOperationResult<bool> operationResult = OperationResult.CreateResult(OperationType.PageNavigation, this, true, DataContext.Empty); bool isInvoked = false; var continuationAction = new ActionContinuationMock { Invoke = result => { result.ShouldEqual(operationResult); isInvoked = true; } }; operation.ContinueWith(continuationAction); isInvoked.ShouldBeFalse(); operation.ToOperationCallback().Invoke(operationResult); isInvoked.ShouldBeTrue(); isInvoked = false; operation.ContinueWith(continuationAction); isInvoked.ShouldBeTrue(); }
IEnumerator loadScene() { isAsync = true; async = Application.LoadLevelAsync(Global.GetInstance().loadName); async.allowSceneActivation = false;//禁止协程加载完自动跳转关卡 yield return async; }
public IEnumerator loadSceneAsync(string sceneName) { async = Application.LoadLevelAsync(sceneName); async.allowSceneActivation = false; yield return async ; }
public void Show(AsyncOperation ao) { BG.SetActive(true); isAsyn = true; this.ao = ao; }
private IEnumerator LoadALevel(string sceneName) { yield return new WaitForSeconds(5f); async = SceneManager.LoadSceneAsync(sceneName); //yield return new WaitForSeconds(6f); yield return async; }
void StreamLevel() { if (nextLevelID >= 0) { level = Application.LoadLevelAdditiveAsync(nextLevelID); level.allowSceneActivation = false; } }
IEnumerator Load() { try { stageName = sc.getStageName().ToString(); print("stageName: " + stageName); // 非同期でロード開始 async = Application.LoadLevelAsync(stageName.ToString()); // デフォルトはtrue。ロード完了したら勝手にシーンきりかえ発生しないよう設定。 async.allowSceneActivation = false; } catch (Exception) { Application.LoadLevelAsync("StageSelect"); yield break; } // 非同期読み込み中の処理 while (async.progress < 0.9f) { loadingText.text = "NowLoading..." + (async.progress * 100).ToString("F0") + "%"; //Debug.Log("ローディングパーセント" + async.progress * 100); lodingBar.value = async.progress; yield return new WaitForEndOfFrame(); } lodingBar.value = 0.9f; loadingText.text = "NowLoading...100%"; state.setState(GameState.NotPlaying); yield return async; }
IEnumerator Start() { // 非同期でロード開始 switch(ButtonC.courceNum){ case 1: async0 = Application.LoadLevelAsync("Stage00"); async0.allowSceneActivation= false; yield return async0; break; case 2: async0 = Application.LoadLevelAsync("Stage01"); async0.allowSceneActivation= false; yield return async0; break; case 3: async0 = Application.LoadLevelAsync("Stage10"); async0.allowSceneActivation= false; yield return async0; break; default: break; } }
public IAsyncOperation <string> InvokeScriptAsync(string scriptName, IEnumerable <string> arguments) => AsyncOperation.FromTask(ct => InvokeScriptAsync(ct, scriptName, arguments?.ToArray()));
// Corourtine to handle all the steps across loading boundaries. IEnumerator LoadLevel() { // Optionally rotate loading screen transform around the camera into view. // We assume here that the loading screen is already facing toward the origin, // and that the progress bar transform (if any) is a child and will follow along. if (loadingScreen != null && loadingScreenDistance > 0.0f) { // Wait until we have tracking. var hmd = SteamVR_Controller.Input((int)OpenVR.k_unTrackedDeviceIndex_Hmd); while (!hmd.hasTracking) { yield return(null); } var tloading = hmd.transform; tloading.rot = Quaternion.Euler(0.0f, tloading.rot.eulerAngles.y, 0.0f); tloading.pos += tloading.rot * new Vector3(0.0f, 0.0f, loadingScreenDistance); var t = loadingScreenTransform != null ? loadingScreenTransform : transform; t.position = tloading.pos; t.rotation = tloading.rot; } _active = this; SteamVR_Events.Loading.Send(true); // Calculate rate for fading in loading screen and progress bar. if (loadingScreenFadeInTime > 0.0f) { fadeRate = 1.0f / loadingScreenFadeInTime; } else { alpha = 1.0f; } var overlay = OpenVR.Overlay; // Optionally create our loading screen overlay. if (loadingScreen != null && overlay != null) { loadingScreenOverlayHandle = GetOverlayHandle("loadingScreen", loadingScreenTransform != null ? loadingScreenTransform : transform, loadingScreenWidthInMeters); if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid) { var texture = new Texture_t(); texture.handle = loadingScreen.GetNativeTexturePtr(); texture.eType = SteamVR.instance.textureType; texture.eColorSpace = EColorSpace.Auto; overlay.SetOverlayTexture(loadingScreenOverlayHandle, ref texture); } } bool fadedForeground = false; // Fade out to compositor SteamVR_Events.LoadingFadeOut.Send(fadeOutTime); // Optionally set a skybox to use as a backdrop in the compositor. var compositor = OpenVR.Compositor; if (compositor != null) { if (front != null) { SteamVR_Skybox.SetOverride(front, back, left, right, top, bottom); // Explicitly fade to the compositor since loading will cause us to stop rendering. compositor.FadeGrid(fadeOutTime, true); yield return(new WaitForSeconds(fadeOutTime)); } else if (backgroundColor != Color.clear) { // Otherwise, use the specified background color. if (showGrid) { // Set compositor background color immediately, and start fading to it. compositor.FadeToColor(0.0f, backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a, true); compositor.FadeGrid(fadeOutTime, true); yield return(new WaitForSeconds(fadeOutTime)); } else { // Fade the foreground color in (which will blend on top of the scene), and then cut to the compositor. compositor.FadeToColor(fadeOutTime, backgroundColor.r, backgroundColor.g, backgroundColor.b, backgroundColor.a, false); yield return(new WaitForSeconds(fadeOutTime + 0.1f)); compositor.FadeGrid(0.0f, true); fadedForeground = true; } } } // Now that we're fully faded out, we can stop submitting frames to the compositor. SteamVR_Render.pauseRendering = true; // Continue waiting for the overlays to fully fade in before continuing. while (alpha < 1.0f) { yield return(null); } // Keep us from getting destroyed when loading the new level, otherwise this coroutine will get stopped prematurely. transform.parent = null; DontDestroyOnLoad(gameObject); if (!string.IsNullOrEmpty(internalProcessPath)) { Debug.Log("Launching external application..."); var applications = OpenVR.Applications; if (applications == null) { Debug.Log("Failed to get OpenVR.Applications interface!"); } else { var workingDirectory = Directory.GetCurrentDirectory(); var fullPath = Path.Combine(workingDirectory, internalProcessPath); Debug.Log("LaunchingInternalProcess"); Debug.Log("ExternalAppPath = " + internalProcessPath); Debug.Log("FullPath = " + fullPath); Debug.Log("ExternalAppArgs = " + internalProcessArgs); Debug.Log("WorkingDirectory = " + workingDirectory); var error = applications.LaunchInternalProcess(fullPath, internalProcessArgs, workingDirectory); Debug.Log("LaunchInternalProcessError: " + error); #if UNITY_EDITOR UnityEditor.EditorApplication.isPlaying = false; #elif !UNITY_METRO System.Diagnostics.Process.GetCurrentProcess().Kill(); #endif } } else { var mode = loadAdditive ? UnityEngine.SceneManagement.LoadSceneMode.Additive : UnityEngine.SceneManagement.LoadSceneMode.Single; if (loadAsync) { Application.backgroundLoadingPriority = ThreadPriority.Low; async = UnityEngine.SceneManagement.SceneManager.LoadSceneAsync(levelName, mode); // Performing this in a while loop instead seems to help smooth things out. //yield return async; while (!async.isDone) { yield return(null); } } else { UnityEngine.SceneManagement.SceneManager.LoadScene(levelName, mode); } } yield return(null); System.GC.Collect(); yield return(null); Shader.WarmupAllShaders(); // Optionally wait a short period of time after loading everything back in, but before we start rendering again // in order to give everything a change to settle down to avoid any hitching at the start of the new level. yield return(new WaitForSeconds(postLoadSettleTime)); SteamVR_Render.pauseRendering = false; // Fade out loading screen. if (loadingScreenFadeOutTime > 0.0f) { fadeRate = -1.0f / loadingScreenFadeOutTime; } else { alpha = 0.0f; } // Fade out to compositor SteamVR_Events.LoadingFadeIn.Send(fadeInTime); // Refresh compositor reference since loading scenes might have invalidated it. compositor = OpenVR.Compositor; if (compositor != null) { // Fade out foreground color if necessary. if (fadedForeground) { compositor.FadeGrid(0.0f, false); compositor.FadeToColor(fadeInTime, 0.0f, 0.0f, 0.0f, 0.0f, false); yield return(new WaitForSeconds(fadeInTime)); } else { // Fade scene back in, and reset skybox once no longer visible. compositor.FadeGrid(fadeInTime, false); yield return(new WaitForSeconds(fadeInTime)); if (front != null) { SteamVR_Skybox.ClearOverride(); } } } // Finally, stick around long enough for our overlays to fully fade out. while (alpha > 0.0f) { yield return(null); } if (overlay != null) { if (progressBarOverlayHandle != OpenVR.k_ulOverlayHandleInvalid) { overlay.HideOverlay(progressBarOverlayHandle); } if (loadingScreenOverlayHandle != OpenVR.k_ulOverlayHandleInvalid) { overlay.HideOverlay(loadingScreenOverlayHandle); } } Destroy(gameObject); _active = null; SteamVR_Events.Loading.Send(false); }
/// <summary> /// Returns the next asynchronous operation to schedule. /// </summary> /// <param name="ops">Operations that can be scheduled.</param> /// <param name="current">The currently scheduled operation.</param> /// <param name="isYielding">True if the current operation is yielding, else false.</param> /// <param name="next">The next operation to schedule.</param> /// <returns>True if there is a next choice, else false.</returns> internal abstract bool GetNextOperation(IEnumerable <AsyncOperation> ops, AsyncOperation current, bool isYielding, out AsyncOperation next);
/// <summary> /// Start loading next scene /// </summary> /// <param name="isRestrat">is restart</param> /// <returns>IEnumerator</returns> // ------------------------------------------------------------------------------------------------------- protected IEnumerator startNowLoadings(bool isRestrat) { yield return(null); // clear error { this.setError(null); } // wait by lock { int i = 0; while (this.m_lockBeforeLoadings.Count > 0) { yield return(null); for (i = this.m_lockBeforeLoadings.Count - 1; i >= 0; i--) { if (!this.m_lockBeforeLoadings[i]) { this.m_lockBeforeLoadings.RemoveAt(i); } } } } // unload if (!isRestrat) { AsyncOperation ao = Resources.UnloadUnusedAssets(); while (!ao.isDone) { yield return(null); } System.GC.Collect(); } // setSceneChangeState { if (!isRestrat) { this.setSceneChangeState(SceneChangeState.StateEnum.NowLoadingMain); } } // CanStreamedLevelBeLoaded { if (!Application.CanStreamedLevelBeLoaded(this.m_nowLoadingSceneName)) { #if UNITY_EDITOR Debug.LogWarning("(#if UNITY_EDITOR) Not found scene in BuildSettings : " + this.m_nowLoadingSceneName); #endif Invoke("showBackToTitleOkDialog", 0.1f); yield break; } } // load scene { if (!isRestrat) { // loadSceneBase { yield return(this.loadSceneBase(progress => { this.m_loadingSceneProgress = progress; })); } this.m_loadingSceneProgress = 1.0f; } } // main { if (!this.hasError()) { yield return(IEnumeratorStartupManager.Instance.startIEnumerator(IEnumeratorStartupManager.BeforeAfter.Before)); if (IEnumeratorStartupManager.Instance.hasError()) { this.setError(IEnumeratorStartupManager.Instance.createErrorMessage()); } } if (!this.hasError()) { yield return(AssetBundleStartupManager.Instance.startAbStartup()); if (AssetBundleStartupManager.Instance.hasError()) { this.setError(AssetBundleStartupManager.Instance.createErrorMessage()); } } if (!this.hasError()) { yield return(WwwStartupManager.Instance.startWwwStartup()); if (WwwStartupManager.Instance.hasError()) { this.setError(WwwStartupManager.Instance.createErrorMessage()); } } if (!this.hasError()) { yield return(IEnumeratorStartupManager.Instance.startIEnumerator(IEnumeratorStartupManager.BeforeAfter.After)); if (IEnumeratorStartupManager.Instance.hasError()) { this.setError(IEnumeratorStartupManager.Instance.createErrorMessage()); } } } // hasError { if (this.hasError()) { DialogManager.Instance.showYesNoDialog(this.m_messagesForError, this.retry, this.showBackToTitleOkDialog); yield break; } } // retry { if (IEnumeratorStartupManager.Instance.hasNotYetContent(IEnumeratorStartupManager.BeforeAfter.Before)) { Invoke("retry", 0.1f); yield break; } if (AssetBundleStartupManager.Instance.hasNotYetContent()) { Invoke("retry", 0.1f); yield break; } if (WwwStartupManager.Instance.hasNotYetContent()) { Invoke("retry", 0.1f); yield break; } if (IEnumeratorStartupManager.Instance.hasNotYetContent(IEnumeratorStartupManager.BeforeAfter.After)) { Invoke("retry", 0.1f); yield break; } } // checkIfNeedToReloadScene { if (AssetBundleStartupManager.Instance.checkIfNeedToReloadScene()) { Invoke("callbackForStartingNowLoading", 0.1f); yield break; } } // SceneChangeStateWatcher { yield return(null); this.setSceneChangeState(SceneChangeState.StateEnum.AllStartupsDonePrev); yield return(null); this.setSceneChangeState(SceneChangeState.StateEnum.AllStartupsDone); yield return(null); this.setSceneChangeState(SceneChangeState.StateEnum.AllStartupsDoneNext); yield return(null); } // wait by lock { int i = 0; while (this.m_lockAfterLoadings.Count > 0) { yield return(null); for (i = this.m_lockAfterLoadings.Count - 1; i >= 0; i--) { if (!this.m_lockAfterLoadings[i]) { this.m_lockAfterLoadings.RemoveAt(i); } } } } // setSceneChangeState { this.setSceneChangeState(SceneChangeState.StateEnum.NowLoadingOutro); } // show ui { UiManager.Instance.showUi(this.m_uiIdentifiersForNextSceneStart, true, false, 0, this.sendNowLoadingDoneSignal, null); } // clear { this.clearContentsAfterLoadingScene(); } }
/// <summary> /// IrcClient used to connect to an IRC Server /// </summary> /// <param name="Server">IRC Server</param> /// <param name="Port">IRC Port (6667 if you are unsure)</param> public IrcClient(string Server, int Port) { op = AsyncOperationManager.CreateOperation(null); this._server = Server; this._port = Port; }
public void press() { int currentSceneIndex=SceneManager.GetActiveScene().buildIndex; string smallsec="ﺦﺒﻄﻤﻟﺍ"; string smallsection="smallsection"; string scenenum="scenenumber"; PlayerPrefs.SetString(smallsection,smallsec); PlayerPrefs.SetInt(scenenum,currentSceneIndex); conn= "URI=file:" +Application.dataPath+"/Plugins/grad.s3db"; dbconn=(IDbConnection) new SqliteConnection(conn); dbconn.Open(); IDbCommand dbcmd=dbconn.CreateCommand(); IDbCommand dbcmd2=dbconn.CreateCommand(); IDbCommand dbcmd3=dbconn.CreateCommand(); IDbCommand dbcmd4=dbconn.CreateCommand(); string sqlQuery="SELECT count(*) FROM kitchen" ; string sqlQuery2="SELECT * FROM kitchen "; string sqlQuery4="DELETE FROM usedscenes"; dbcmd.CommandText=sqlQuery; dbcmd2.CommandText=sqlQuery2; dbcmd4.CommandText=sqlQuery4; dbcmd4.ExecuteNonQuery(); count = Convert.ToInt32(dbcmd.ExecuteScalar()); IDataReader reader=dbcmd2.ExecuteReader(); while(reader.Read()) { int idd = reader.GetInt32(0); firstlist.Add(idd); } // if (Instance == null) // { DontDestroyOnLoad(this.gameObject); Instance = this; firstlist.Sort(); int min0=firstlist[0]; int max0=firstlist[firstlist.Count -1]; max0=max0+1; int num=UnityEngine.Random.Range(min0,max0); usednumbers.Add(num); string sqlQuery3="INSERT INTO usedscenes (id) VALUES "+"("+num+")"; dbcmd3.CommandText=sqlQuery3; dbcmd3.ExecuteNonQuery(); startTime=Time.time; AsyncOperation asyncLoad = SceneManager.LoadSceneAsync(num); // } /* else if (Instance != this) { Destroy (gameObject); } */ }
[STAThread] // Added to support UX static void Main(string[] args) { CrmServiceClient service = null; try { service = SampleHelpers.Connect("Connect"); if (service.IsReady) { #region Sample Code #region Set up SetUpSample(service); #endregion Set up #region Demonstrate // Get a system user to use as the sender. var emailSenderRequest = new WhoAmIRequest(); var emailSenderResponse = service.Execute(emailSenderRequest) as WhoAmIResponse; // Set trackingId for bulk mail request. Guid trackingId = Guid.NewGuid(); var bulkMailRequest = new SendBulkMailRequest() { // Create a query expression for the bulk operation to use to retrieve // the contacts in the email list. Query = new QueryExpression() { EntityName = Contact.EntityLogicalName, ColumnSet = new ColumnSet(new String[] { "contactid" }), Criteria = new FilterExpression() { Conditions = { new ConditionExpression("contactid", ConditionOperator.In, _contactsIds) } } }, // Set the Sender. Sender = new EntityReference(SystemUser.EntityLogicalName, emailSenderResponse.UserId), // Set the RegardingId - this field is required. //RegardingId = Guid.Empty, //RegardingType = SystemUser.EntityLogicalName, // Use a built-in Microsoft Dynamics CRM email template. // NOTE: The email template's "template type" must match the type of // customers in the email list. Our list contains contacts, so our // template must be for contacts. TemplateId = new Guid("07B94C1D-C85F-492F-B120-F0A743C540E6"), RequestId = trackingId }; // Execute the async bulk email request var resp = (SendBulkMailResponse) service.Execute(bulkMailRequest); Console.WriteLine(" Sent Bulk Email."); #endregion #region Monitoring SendBulkEmail Console.WriteLine(); Console.WriteLine("Starting monitoring process.."); // Now that we've executed the bulk operation, we need to retrieve it // using our tracking Id. var bulkQuery = new QueryByAttribute() { EntityName = AsyncOperation.EntityLogicalName, ColumnSet = new ColumnSet(new string[] { "requestid" }), Attributes = { "requestid" }, Values = { trackingId } }; // Retrieve the bulk email async operation. EntityCollection aResponse = service.RetrieveMultiple(bulkQuery); Console.WriteLine(" Retrieved Bulk Email Async Operation."); // Monitor the async operation via polling. int secondsTicker = ARBITRARY_MAX_POLLING_TIME; AsyncOperation createdBulkMailOperation = null; Console.WriteLine(" Checking operation's state for " + ARBITRARY_MAX_POLLING_TIME + " seconds."); Console.WriteLine(); while (secondsTicker > 0) { // Make sure the async operation was retrieved. if (aResponse.Entities.Count > 0) { // Grab the one bulk operation that has been created. createdBulkMailOperation = (AsyncOperation)aResponse.Entities[0]; // Check the operation's state. if (createdBulkMailOperation.StateCode.Value != AsyncOperationState.Completed) { // The operation has not yet completed. // Wait a second for the status to change. System.Threading.Thread.Sleep(1000); secondsTicker--; // Retrieve a fresh version the bulk delete operation. aResponse = service.RetrieveMultiple(bulkQuery); } else { // Stop polling because the operation's state is now complete. secondsTicker = 0; } } else { // Wait a second for the async operation to activate. System.Threading.Thread.Sleep(1000); secondsTicker--; // Retrieve the entity again aResponse = service.RetrieveMultiple(bulkQuery); } } // When the bulk email operation has completed, all sent emails will // have a status of "Pending Send" and will be picked up by your email // router. Alternatively, you can then use BackgroundSendEmail to download // all the emails created with the SendBulkEmail message. // See the BackgroundSendEmail sample for an example. #endregion #region Check success // Validate async operation succeeded if (createdBulkMailOperation.StateCode.Value == AsyncOperationState.Completed) { Console.WriteLine("Operation Completed."); } else { Console.WriteLine("Operation not completed yet."); } #region Clean up CleanUpSample(service); #endregion Clean up } #endregion Demonstrate #endregion Sample Code else { const string UNABLE_TO_LOGIN_ERROR = "Unable to Login to Common Data Service"; if (service.LastCrmError.Equals(UNABLE_TO_LOGIN_ERROR)) { Console.WriteLine("Check the connection string values in cds/App.config."); throw new Exception(service.LastCrmError); } else { throw service.LastCrmException; } } } catch (Exception ex) { SampleHelpers.HandleException(ex); } finally { if (service != null) { service.Dispose(); } Console.WriteLine("Press <Enter> to exit."); Console.ReadLine(); } }
/// <summary> /// Async level loading /// </summary> /// <param name="levelName"></param> /// <returns></returns> private IEnumerator LoadLevel(string levelName) { _async = SceneManager.LoadSceneAsync(levelName); yield return(_async); }
IEnumerator LoadLevelWithRealProgress(string name) { //print("4"); yield return(new WaitForSeconds(1)); ao = SceneManager.LoadSceneAsync(name); ao.allowSceneActivation = false; while (!ao.isDone) { progressBar.value = ao.progress; if (ao.progress == 0.9f) { progressBar.value = 1.0f; if (LoadImmediately) { //TouchButton.GetComponent<Button>().interactable = false; if (MainMenuController.instance != null) { StartCoroutine(MainMenuController.instance.BeginFade(true, 1.5f)); } else if (LevelSelectSceneController.instance != null) { StartCoroutine(LevelSelectSceneController.instance.BeginFade(true, 1.5f)); } else if (GameSceneControllerLevel.instance != null) { StartCoroutine(GameSceneControllerLevel.instance.BeginFade(true, 1.5f)); } else if (SurvivalLevelSelectSceneController.instance != null) { StartCoroutine(SurvivalLevelSelectSceneController.instance.BeginFade(true, 1.5f)); } else if (WorldSceneController.instance != null) { StartCoroutine(WorldSceneController.instance.BeginFade(true, 1.5f)); } } else { //LoadingSprite.SetActive(false); //tapToStartSprite.SetActive(true); //TouchButton.GetComponent<Button>().interactable = true; } //if (Input.GetKeyDown(KeyCode.F)) //if(Input.GetTouch(0).phase == TouchPhase.Began) //{ //print("TOUCHED"); //float fadeTime = fader.GetComponent<Fading>().BeginFade(1); //yield return new WaitForSeconds(fadeTime); //MainMenuController.instance.BeginFade(); // //GameSceneController.instance.RestartGame(); //GoToLevel(name); //} } //print(ao.progress); yield return(null); } print("End"); }
public WaitForAsyncOperation(AsyncOperation asyncOp) { this.asyncOp = asyncOp; }
/// <summary> /// Returns the next boolean choice. /// </summary> /// <param name="current">The currently scheduled operation.</param> /// <param name="maxValue">The max value.</param> /// <param name="next">The next boolean choice.</param> /// <returns>True if there is a next choice, else false.</returns> internal abstract bool GetNextBooleanChoice(AsyncOperation current, int maxValue, out bool next);
public static void StartLoadingScene() { SceneAsyncOperation = SceneManager.LoadSceneAsync(SceneName); SceneAsyncOperation.allowSceneActivation = false; }
IEnumerator UnloadScene() { AsyncOperation operation = SceneManager.UnloadSceneAsync(SceneManager.GetActiveScene().buildIndex); yield return null; }
public override bool Update() { #if UNITY_EDITOR if (AssetBundleLoadManager.SimulateAssetBundleInEditor) { string[] levelPaths = AssetDatabase.GetAssetPathsFromAssetBundleAndAssetName(m_AssetBundleName, m_AssetName); if (levelPaths.Length == 0) { ///@TODO: The error needs to differentiate that an asset bundle name doesn't exist // from that there right scene does not exist in the asset bundle... Debug.LogError("There is no scene with name \"" + m_AssetName + "\" in " + m_AssetBundleName); return(true); } if (m_IsAdditive) { m_Request = EditorApplication.LoadLevelAdditiveAsyncInPlayMode(levelPaths[0]); } else { m_Request = EditorApplication.LoadLevelAsyncInPlayMode(levelPaths[0]); } m_IsDone = true; DoCallback(); return(false); } #endif if (m_Request != null && m_Request.isDone) { m_IsDone = true; DoCallback(); return(false); } else if (m_Request != null && !m_Request.isDone) { return(true); } LoadedAssetBundle bundle = AssetBundleLoadManager.Instance.GetLoadedAssetBundle(m_AssetBundleName, out m_DownloadingError); if (bundle != null) { if (m_IsAdditive) { m_Request = Application.LoadLevelAdditiveAsync(m_AssetName); } else { m_Request = Application.LoadLevelAsync(m_AssetName); } return(true); } else { return(true); } }
/// <inheritdoc/> public bool GetNextOperation(IEnumerable <AsyncOperation> ops, AsyncOperation current, bool isYielding, out AsyncOperation next) { if (this.PrefixStrategy.HasReachedMaxSchedulingSteps()) { return(this.SuffixStrategy.GetNextOperation(ops, current, isYielding, out next)); } else { return(this.PrefixStrategy.GetNextOperation(ops, current, isYielding, out next)); } }
private void Start() { aLoadScene = SceneManager.LoadSceneAsync(mainScene); aLoadScene.allowSceneActivation = false; }
public IEnumerator End() { bool victory = true; if (!Input.GetKey(KeyCode.C)) { for (int i = 0; i < Map.m.tower_fabs.Length + 1; i++) { if (Map.m.sectors[i].color != Sector.BlockColor.Cyan) { victory = false; break; } } } AsyncOperation o = null; if (!victory) { o = Application.LoadLevelAsync("scene_garage"); o.allowSceneActivation = false; } GameObject p = Chassis.c.gameObject; while (p.transform.position.z > -200f) { p.transform.position += new Vector3(0f, 0f, -100f * Time.deltaTime); aud.volume -= Time.deltaTime * 0.5f; yield return(null); } // Do clean up or anything else HERE // Unlocked a weapon!? if (GarageController.selected_sector.weapon_unlock >= 0) { GarageController.UnlockWeapon(GarageController.selected_sector.weapon_unlock); } // Won with a new weapon!? bool save_settings = false; for (int i = 0; i < GarageController.weapons.Length; i++) { if ((Chassis.c.sc_class_1 && Chassis.c.fore != null && Chassis.c.fore.weapon_name.Equals(GarageController.weapons[i].weapon_name)) || (Chassis.c.sc_class_2 && Chassis.c.turret != null && Chassis.c.turret.weapon_name.Equals(GarageController.weapons[i].weapon_name))) { Settings.won_with_which_weapons[i] = true; bool unlocked_jack_achieve = true; for (int j = 0; j < Settings.won_with_which_weapons.Length; j++) { if (!Settings.won_with_which_weapons[j]) { unlocked_jack_achieve = false; j = Settings.won_with_which_weapons.Length; } } if (unlocked_jack_achieve) { Utilities.u.UnlockAchievement("Jack of All Guns"); } save_settings = true; } } if (save_settings) { Settings.SaveSettings(); } // Okay clean up is all done. if (!victory) { o.allowSceneActivation = true; while (!o.isDone) { yield return(true); } p.transform.position = Vector3.zero; p.transform.rotation = Quaternion.identity; } else { //Achievement Utilities.u.UnlockAchievement("Golden Chariot"); Destroy(Chassis.c.gameObject); Destroy(Map.m); Application.LoadLevelAsync("scene_victory"); } Destroy(gameObject); }
public void StartLoadScene(MonoBehaviour mono, AsyncOperation async) { asyncOperation = async; mono.StartCoroutine(LoadingScene()); }
/// <summary> /// Alternate keys may not be active immediately after a solution defining them is installed. /// This method polls the metadata for a specific entity /// to delay execution of the rest of the sample until the alternate keys are ready. /// </summary> /// <param name="service">Specifies the service to connect to.</param> /// <param name="asyncJob">The system job that creates the index to support the alternate key</param> /// <param name="iteration">The number of times this method has been called.</param> /// private static bool VerifyBookCodeKeyIsActive(IOrganizationService service, EntityReference asyncJob = null, int iteration = 0) { if (iteration > 5) { //Give up return(false); } if (iteration == 0) //only the first time { //Get whether the Entity Key index is active from the metadata EntityQueryExpression entityQuery = new EntityQueryExpression(); entityQuery.Criteria = new MetadataFilterExpression(LogicalOperator.And) { Conditions = { { new MetadataConditionExpression("LogicalName", MetadataConditionOperator.Equals, "sample_book") } } }; entityQuery.Properties = new MetadataPropertiesExpression("Keys"); RetrieveMetadataChangesRequest metadataRequest = new RetrieveMetadataChangesRequest() { Query = entityQuery }; RetrieveMetadataChangesResponse metadataResponse = (RetrieveMetadataChangesResponse)service.Execute(metadataRequest); EntityKeyMetadata bookcodekey = metadataResponse.EntityMetadata.FirstOrDefault().Keys.FirstOrDefault(); if (bookcodekey.EntityKeyIndexStatus == EntityKeyIndexStatus.Active) { return(true); } else { iteration++; return(VerifyBookCodeKeyIsActive(service, bookcodekey.AsyncJob, iteration)); } } else { //Check the status of the system job that is should indicate that the alternate key index is active. AsyncOperation systemJob = (AsyncOperation)service.Retrieve(asyncJob.LogicalName, asyncJob.Id, new ColumnSet("statecode", "statuscode")); if (systemJob.StateCode == AsyncOperationState.Completed) //Completed { if (!systemJob.StatusCode.Value.Equals(30)) //Not Succeeded { //Delete the system job and try to reactivate service.Delete(asyncJob.LogicalName, asyncJob.Id); ReactivateEntityKeyRequest reactivateRequest = new ReactivateEntityKeyRequest() { EntityLogicalName = "sample_book", EntityKeyLogicalName = "sample_bookcode" }; ReactivateEntityKeyResponse reactivateResponse = (ReactivateEntityKeyResponse)service.Execute(reactivateRequest); //Get the system job created by the reactivate request QueryByAttribute systemJobQuery = new QueryByAttribute("asyncoperation"); systemJobQuery.AddAttributeValue("primaryentitytype", "sample_book"); systemJobQuery.AddOrder("createdon", OrderType.Descending); systemJobQuery.TopCount = 1; systemJobQuery.ColumnSet = new ColumnSet("asyncoperationid", "name"); EntityCollection systemJobs = service.RetrieveMultiple(systemJobQuery); asyncJob = systemJobs.Entities.FirstOrDefault().ToEntityReference(); iteration++; return(VerifyBookCodeKeyIsActive(service, asyncJob, iteration)); } else { //It succeeded return(true); } } else { //Give it more time to complete Thread.Sleep(TimeSpan.FromSeconds(30)); iteration++; return(VerifyBookCodeKeyIsActive(service, asyncJob, iteration)); } } }
internal void OpenNextPresent(Type presentType, LoadRuleData rule, object openArg, Action callback) { if (null == rule) { rule = Present.DefaultLoadRule; } #if LOG_DEBUG Debug.Log(string.Format("PRESENT<{0}={1:X8}>:NEXT:{2}, RULE:{3}, ARG:{4}, CB:{5}, STACK_TRACE:\n{6}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, null != presentType ? presentType.Name : "null", rule, openArg, callback, new System.Diagnostics.StackTrace(true).ToString())); #endif// LOG_DEBUG #if LOG_MEMORY var stateOfPresent = null != this.loadedPresent ? this.loadedPresent.GetState() : -1; Debug.Log(string.Format("APP:{0}, {1}, {2}", DebugImpl.CreateUptimeChunk(), DebugImpl.CreatePresentChunk("AT", presentType, -1), DebugImpl.CreatePresentChunk("EVENT:SET_PRESENT_PREV", this.presentType, stateOfPresent))); #endif// LOG_MEMORY this.ClosePresent(presentType); if (null != this.asyncOperFakeOpenForGarbageCollect || null != this.asyncOper || this.fastOpenWait) { #if LOG_DEBUG Debug.Log(string.Format("PRESENT<{0}={1:X8}>:NEXT_DUPLICATED:{2}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, null != presentType ? presentType.Name : "null")); #endif// LOG_DEBUG this.OpenPresentWait(presentType, rule, openArg, callback); return; } else if (null != this.wait) { Debug.LogError(string.Format("PRESENT<{0}={1:X8}>:NEXT_DUPLICATED_EXCEPTION#2:{2}, RULE:{3}, ARG:{4}, CB{5}, WAIT:{6}, CURRENT:{7}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, null != presentType ? presentType.Name : "null", rule, openArg, callback, this.wait, this.presentType)); return; } this.presentTypePrev = this.presentType; this.presentType = presentType; this.openArg = openArg; this.openCallback = callback; this.isChanging = true; Preference.Save(); this.preloadPresent = (Present)Activator.CreateInstance(this.presentType); #if LOG_DEBUG Debug.Log(string.Format("PRESENT<{0}={1:X8}>:CREATE_INSTANCE:<{2}={3:X8}>", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, null != this.preloadPresent ? this.preloadPresent.GetType().Name : "null", null != this.preloadPresent ? (uint)this.preloadPresent.GetHashCode() : 0u)); #endif// LOG_DEBUG try { this.preloadPresent.OnPreloading(); } catch (Exception e) { Debug.LogError(string.Format("PRESENT<{0}={1:X8}>:LOAD_EXCEPT:{2}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, e)); } switch (rule.Rule) { case LoadRule.FlushGarbage: this.asyncOperFakeOpenForGarbageCollect = SceneManager.LoadSceneAsync("Next"); break; case LoadRule.Direct: if (this.preloadPresent.DoOpen) { this.asyncOper = SceneManager.LoadSceneAsync(this.presentType.Name); } else { this.fastOpenWait = true; } break; case LoadRule.PreloadedScene: this.asyncOper = rule.Preloaded; break; } }
public override void OnEnter() { _op = Resources.UnloadUnusedAssets(); }
IEnumerator loadScene() { AsyncOperation async = Application.LoadLevelAsync(2); yield return(async); }
public IEnumerator LoadLevel(string nameScene) { ao = SceneManager.LoadSceneAsync(nameScene); ao.allowSceneActivation = true; yield return(new WaitForEndOfFrame()); }
private void SceneLoadOnCompleted(AsyncOperation obj) { Debug.Log("Scene load completed."); }
IEnumerator LoadSceneAsync(string loadSceneName, AssetBundle depBundle) { AsyncOperation async = SceneManager.LoadSceneAsync(loadSceneName, LoadSceneMode.Single); yield return(async); }
internal void UpdatePresent() { if (this.isResumeStart) { this.isSuspended = false; this.isResumeStart = false; if (null != this.loadedPresent) { try { if (this.loadedPresent.isPresentSuspended) { this.loadedPresent.isPresentSuspended = false; this.loadedPresent.OnResume(); } } catch (Exception e) { Debug.LogError(string.Format("PRESENT<{0}={1:X8}>:ONRESUME_EXCEPT:{2}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, e)); } } } else if (this.isSuspended) { return; } var loaded = false; if (null != this.preloadPresent) { if (this.fastOpenWait) { if (this.preloadPresent.DoOpen) { this.fastOpenWait = false; this.asyncOper = SceneManager.LoadSceneAsync(this.presentType.Name); } else { return; } } else if (null != this.asyncOperFakeOpenForGarbageCollect) { if (this.asyncOperFakeOpenForGarbageCollect.isDone && this.preloadPresent.DoOpen) { this.asyncOperFakeOpenForGarbageCollect = null; this.asyncOper = SceneManager.LoadSceneAsync(this.presentType.Name); } else { return; } } if (null != this.asyncOper) { if (!this.asyncOper.allowSceneActivation) { this.asyncOper.allowSceneActivation = true; } if (!this.asyncOper.isDone) { this.preloadPresent.loadingProgress = this.asyncOper.progress; return; } this.asyncOper = null; this.OpenPresent(); loaded = true; } } if (loaded) { var openCallback = this.openCallback; this.openCallback = null; if (null != openCallback) { openCallback(); } if (null != this.openListener) { this.openListener(); } this.isChanging = false; } if (null != this.loadedPresent) { try { this.loadedPresent.OnUpdate(); } catch (Exception e) { Debug.LogError(string.Format("PRESENT<{0}={1:X8}>:ONUPDATE_EXCEPT:{2}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, e)); } var fsm = this.loadedPresent.fsm; if (fsm.HasStateTasks()) { try { fsm.RunStateTasks(); } catch (Exception e) { Debug.LogError(string.Format("PRESENT<{0}={1:X8}>:STATETASK_EXCEPT:{2}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, e)); } } if (fsm.HasTasks()) { try { fsm.RunTasks(); } catch (Exception e) { Debug.LogError(string.Format("PRESENT<{0}={1:X8}>:TASK_EXCEPT:{2}", this.CurrentPresentName, (uint)this.CurrentPresentHashCode, e)); } } } if (loaded) { if (null != this.wait) { var w = this.wait; this.wait = null; this.OpenNextPresent(w.PresentType, w.Rule, w.OpenArg, w.Callback); } } if (Input.GetKeyDown(KeyCode.Escape)) { this.Back(); } }
void CreateOperationOnCompleted(AsyncOperation obj) { if (m_CurrentRequest == null) { //If we lost our m_CurrentRequest request reference, we can't risk doing anything. return; } if (m_CurrentRequest.result != UnityWebRequest.Result.ProtocolError) { var jsonParser = new JSONParser(m_CurrentRequest.downloadHandler.text); var json = jsonParser.Parse(); var abort = false; try { var projectInfo = ExtractProjectInfoFromJson(json); try { ServicesRepository.DisableAllServices(shouldUpdateApiFlag: false); //Only register before creation. Remove first in case it was already added. //TODO: Review to avoid dependency on project refreshed UnityConnect.instance.ProjectStateChanged -= OnProjectStateChangedAfterCreation; UnityConnect.instance.ProjectStateChanged += OnProjectStateChangedAfterCreation; BindProject(projectInfo); } catch (Exception ex) { if (exceptionCallback != null) { exceptionCallback.Invoke(ex); abort = true; } else { //If there is no exception callback, we have to at least log it Debug.LogException(ex); } } if (!abort) { createButtonCallback?.Invoke(projectInfo); } } finally { m_CurrentRequest?.Dispose(); m_CurrentRequest = null; } } else if (m_CurrentRequest.responseCode == k_HttpStatusCodeUnprocessableEntity) { m_CurrentRequest?.Dispose(); m_CurrentRequest = null; m_CreateIteration++; RequestCreateOperation(); } else { try { var ex = new UnityConnectWebRequestException(L10n.Tr(k_CouldNotCreateProjectMessage)) { error = m_CurrentRequest.error, method = m_CurrentRequest.method, timeout = m_CurrentRequest.timeout, url = m_CurrentRequest.url, responseHeaders = m_CurrentRequest.GetResponseHeaders(), responseCode = m_CurrentRequest.responseCode, isHttpError = (m_CurrentRequest.result == UnityWebRequest.Result.ProtocolError), isNetworkError = (m_CurrentRequest.result == UnityWebRequest.Result.ConnectionError), }; if (exceptionCallback != null) { exceptionCallback.Invoke(ex); } else { //If there is no exception callback, we have to at least log it Debug.LogException(ex); } } finally { m_CurrentRequest?.Dispose(); m_CurrentRequest = null; } } }
public WaitForAsyncOperation(AsyncOperation operation, bool allowActivation = true) { _operation = operation; _operation.allowSceneActivation = allowActivation; }
/// <summary> /// Returns the next integer choice. /// </summary> /// <param name="current">The currently scheduled operation.</param> /// <param name="maxValue">The max value.</param> /// <param name="next">The next integer choice.</param> /// <returns>True if there is a next choice, else false.</returns> internal abstract bool GetNextIntegerChoice(AsyncOperation current, int maxValue, out int next);
public LoadRuleData(AsyncOperation preloaded) { this.rule = LoadRule.PreloadedScene; this.preloadedScene = preloaded; }