Bienvenido a nuestra página, en este sitio vas a hallar la respuesta a lo que andabas buscando.
Solución:
Hay muchas formas de esperar en Unity. Es realmente simple, pero creo que vale la pena cubrir la mayoría de las formas de hacerlo:
1.Con una corrutina y WaitForSeconds.
Es, con mucho, la forma más sencilla. Coloque todo el código que necesita para esperar un tiempo en una función de rutina y luego puede esperar con WaitForSeconds. Tenga en cuenta que en la función de rutina, llama a la función con StartCoroutine(yourFunction).
El siguiente ejemplo rotará 90 grados, esperará 4 segundos, rotará 40 grados y esperará 2 segundos, y finalmente rotará, rotará 20 grados.
void Start()
StartCoroutine(waiter());
IEnumerator waiter()
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
yield return new WaitForSeconds(4);
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
yield return new WaitForSeconds(2);
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
2.Con una corrutina y WaitForSecondsRealtime.
La única diferencia entre WaitForSeconds y WaitForSecondsRealtime es eso WaitForSecondsRealtime está usando un tiempo sin escalar para esperar, lo que significa que al pausar un juego con Time.timeScale, los WaitForSecondsRealtime la función no se vería afectada pero WaitForSeconds haría.
void Start()
StartCoroutine(waiter());
IEnumerator waiter()
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
yield return new WaitForSecondsRealtime(4);
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
yield return new WaitForSecondsRealtime(2);
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
Espere y aún podrá ver cuánto tiempo ha esperado:
3.Con una corrutina e incrementando una variable en cada cuadro con Time.deltaTime.
Un buen ejemplo de esto es cuando necesita que el temporizador muestre en la pantalla cuánto tiempo ha esperado. Básicamente como un temporizador.
También es bueno cuando quieres interrumpir la espera / dormir con un boolean variable cuando es true. Aquí es donde yield break; puede ser usado.
bool quit = false;
void Start()
StartCoroutine(waiter());
IEnumerator waiter()
float counter = 0;
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
float waitTime = 4;
while (counter < waitTime)
//Increment Timer until counter >= waitTime
counter += Time.deltaTime;
Debug.Log("We have waited for: " + counter + " seconds");
//Wait for a frame so that Unity doesn't freeze
//Check if we want to quit this function
if (quit)
//Quit function
yield break;
yield return null;
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
waitTime = 2;
//Reset counter
counter = 0;
while (counter < waitTime)
//Increment Timer until counter >= waitTime
counter += Time.deltaTime;
Debug.Log("We have waited for: " + counter + " seconds");
//Check if we want to quit this function
if (quit)
//Quit function
yield break;
//Wait for a frame so that Unity doesn't freeze
yield return null;
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
Aún puede simplificar esto moviendo el while bucle en otra función de corrutina y cediéndola y también poder verla contando e incluso interrumpir el contador.
bool quit = false;
void Start()
StartCoroutine(waiter());
IEnumerator waiter()
//Rotate 90 deg
transform.Rotate(new Vector3(90, 0, 0), Space.World);
//Wait for 4 seconds
float waitTime = 4;
yield return wait(waitTime);
//Rotate 40 deg
transform.Rotate(new Vector3(40, 0, 0), Space.World);
//Wait for 2 seconds
waitTime = 2;
yield return wait(waitTime);
//Rotate 20 deg
transform.Rotate(new Vector3(20, 0, 0), Space.World);
IEnumerator wait(float waitTime)
float counter = 0;
while (counter < waitTime)
//Increment Timer until counter >= waitTime
counter += Time.deltaTime;
Debug.Log("We have waited for: " + counter + " seconds");
if (quit)
//Quit function
yield break;
//Wait for a frame so that Unity doesn't freeze
yield return null;
Espere / duerma hasta que la variable cambie o sea igual a otro valor:
4.Con una corrutina y el WaitUntil función:
Espere hasta que una condición se convierta true. Un ejemplo es una función que espera a que la puntuación del jugador sea 100 luego carga el siguiente nivel.
float playerScore = 0;
int nextScene = 0;
void Start()
StartCoroutine(sceneLoader());
IEnumerator sceneLoader()
Debug.Log("Waiting for Player score to be >=100 ");
yield return new WaitUntil(() => playerScore >= 10);
Debug.Log("Player score is >=100. Loading next Leve");
//Increment and Load next scene
nextScene++;
SceneManager.LoadScene(nextScene);
5.Con una corrutina y el WaitWhile función.
Espere mientras una condición es true. Un ejemplo es cuando desea salir de la aplicación cuando se presiona la tecla Escape.
void Start()
StartCoroutine(inputWaiter());
IEnumerator inputWaiter()
Debug.Log("Waiting for the Exit button to be pressed");
yield return new WaitWhile(() => !Input.GetKeyDown(KeyCode.Escape));
Debug.Log("Exit button has been pressed. Leaving Application");
//Exit program
Quit();
void Quit()
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#else
Application.Quit();
#endif
6.Con el Invoke función:
Puede llamar a Dile a Unity que llame a la función en el futuro. Cuando llamas al Invoke función, puede pasar el tiempo de espera antes de llamar a esa función a su segundo parámetro. El siguiente ejemplo llamará al feedDog() función después 5 segundos el Invoke se llama.
void Start()
Invoke("feedDog", 5);
Debug.Log("Will feed dog after 5 seconds");
void feedDog()
Debug.Log("Now feeding Dog");
7.Con el Update() función y Time.deltaTime.
Es como # 3 excepto que no usa corrutina. Utiliza el Update función.
El problema con esto es que requiere tantas variables, por lo que no se ejecutará siempre, sino solo una vez cuando el temporizador termine después de la espera.
float timer = 0;
bool timerReached = false;
void Update()
if (!timerReached)
timer += Time.deltaTime;
if (!timerReached && timer > 5)
Debug.Log("Done waiting");
feedDog();
//Set to false so that We don't run this again
timerReached = true;
void feedDog()
Debug.Log("Now feeding Dog");
Todavía hay otras formas de esperar en Unity, pero definitivamente debes conocer las mencionadas anteriormente, ya que eso facilita la creación de juegos en Unity. Cuándo usar cada uno depende de las circunstancias.
Para su problema particular, esta es la solución:
IEnumerator showTextFuntion()
TextUI.text = "Welcome to Number Wizard!";
yield return new WaitForSeconds(3f);
TextUI.text = ("The highest number you can pick is " + max);
yield return new WaitForSeconds(3f);
TextUI.text = ("The lowest number you can pick is " + min);
Y para llamar / iniciar la función de rutina desde su función de inicio o actualización, lo llama con
StartCoroutine (showTextFuntion());
Estuvo en lo correcto al usar WaitForSeconds. Pero sospecho que intentó usarlo sin corrutinas. Así es como debería funcionar:
public void SomeMethod()
StartCoroutine(SomeCoroutine());
private IEnumerator SomeCoroutine()
TextUI.text = "Welcome to Number Wizard!";
yield return new WaitForSeconds (3);
TextUI.text = ("The highest number you can pick is " + max);
yield return new WaitForSeconds (3);
TextUI.text = ("The lowest number you can pick is " + min);
Con .Net 4.x puede utilizar el patrón asincrónico basado en tareas (TAP) para lograr esto:
// .NET 4.x async-await
using UnityEngine;
using System.Threading.Tasks;
public class AsyncAwaitExample : MonoBehaviour
private async void Start()
Debug.Log("Wait.");
await WaitOneSecondAsync();
DoMoreStuff(); // Will not execute until WaitOneSecond has completed
private async Task WaitOneSecondAsync()
await Task.Delay(TimeSpan.FromSeconds(1));
Debug.Log("Finished waiting.");
esta es una característica para usar .Net 4.x con Unity, consulte este enlace para obtener una descripción al respecto
y este enlace para un proyecto de muestra y compararlo con una rutina
Pero ten cuidado ya que la documentación dice que Esto no es un reemplazo completo con coroutine.