Wie machen die das Skript warten/schlafen in einer einfachen Art und Weise, in der Einheit

Gibt es viele Möglichkeiten, zu warten, in der Einheit. Es ist wirklich einfach, aber ich denke es lohnt sich für die meisten Möglichkeiten, das zu tun diese:

1.Mit einer coroutine und WaitForSeconds.

Das ist bei weitem der einfachste Weg. Setzen Sie den code, müssen Sie warten, für einige Zeit in eine coroutine Funktion, dann kann man darauf warten, mit WaitForSeconds. Beachten Sie, dass in coroutine Funktion, rufen Sie die Funktion mit StartCoroutine(yourFunction).

Beispiel unten drehen um 90 Grad, warten Sie 4 Sekunden, drehen 40 Grad und warten Sie 2 Sekunden, und dann drehen, drehen Sie 20 Grad.

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.Mit einer coroutine und WaitForSecondsRealtime.

Der einzige Unterschied zwischen WaitForSeconds und WaitForSecondsRealtime ist, dass WaitForSecondsRealtime ist mit nicht skalierten Zeit zu warten, was bedeutet, dass beim anhalten ein Spiel mit Time.timeScale, die WaitForSecondsRealtime Funktion nicht beeinträchtigt würden, sondern WaitForSeconds würde.

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);
}

Warten und noch in der Lage sein zu sehen, wie lange Sie gewartet haben:

3.Mit einer coroutine und das Inkrementieren einer variable zu jedem Rahmen mit Zeit.deltaTime.

Ein gutes Beispiel dafür ist, wenn Sie müssen die timer-Anzeige auf dem Bildschirm, wie viel Zeit man hat gewartet. Im Grunde wie ein timer.

Ist es auch gut, wenn Sie wollen, zu unterbrechen, das warten/schlafen mit einem boolean variable, wenn es wahr ist. Dies ist, wo yield break; verwendet werden kann.

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);
}

Kann man noch vereinfachen dies, indem die while Schleife in eine andere coroutine Funktion und nachgiebig und auch noch in der Lage sein, es zu sehen, zu zählen und sogar zu unterbrechen, den Zähler.

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;
    }
}

Warten/Schlafen bis in die variable ändert oder gleich einem anderen Wert:

4.Mit einer coroutine und die WaitUntil Funktion:

Warten, bis eine Bedingung true. Ein Beispiel ist eine Funktion, die wartet, für Spieler zu sein 100 lädt dann die nächste Stufe.

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.Mit einer coroutine und die WaitWhile Funktion.

Warten Sie, während eine Bedingung ist true. Ein Beispiel ist, wenn Sie wollen, exit app, wenn die escape-Taste gedrückt wird.

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.Mit der Aufzurufen Funktion:

Können Sie anrufen sagen, die Einheit aufrufen, Funktion in der Zukunft. Beim Aufruf der Invoke Funktion, die Sie übergeben können, die Zeit zu warten, bevor Sie die Funktion aufrufen, um seinen zweiten parameter. Das Beispiel unten werden die feedDog() Funktion nach 5 Sekunden die Invoke genannt wird.

void Start()
{
    Invoke("feedDog", 5);
    Debug.Log("Will feed dog after 5 seconds");
}

void feedDog()
{
    Debug.Log("Now feeding Dog");
}

7.Mit der Update() Funktion und Zeit.deltaTime.

Es ist genau wie #3 außer, dass es nicht coroutine. Es verwendet die Update Funktion.

Das problem mit diesem ist, dass es erfordert so viele Variablen, so dass es nicht jedes mal, sondern nur einmal, wenn der timer vorbei ist, nach dem warten.

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");
}

Gibt es noch andere Möglichkeiten, um zu warten, in der Einheit, aber Sie sollten auf jeden Fall wissen, diejenigen, die oben erwähnt so, dass macht es einfacher zu machen, Spiele in der Einheit. Ihre Verwendung hängt von den Umständen ab.

Für Ihr spezielles Problem, das ist die Lösung:

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);
}

Und aufrufen/starten der coroutine Funktion von Ihrem start-oder Update-Funktion, rufen Sie es mit

StartCoroutine (showTextFuntion());

InformationsquelleAutor Programmer