Temps, coroutines et nombres aléatoires

L'horloge#

Chaque jeu démarre sa propre horloge en chargeant le monde : Time.time diffère d'un joueur à l'autre. Pour s'accorder sur un instant, utilise l'horloge du serveur.

Attendre : les coroutines#

using System.Collections;
using NodeWorld.Flux;
using Flux;

namespace MonMonde
{
    public class Fontaine : FluxScript
    {
        public ParticleSystem eau;

        protected override void Start() => StartCoroutine(Cycle());

        private IEnumerator Cycle()
        {
            while (true)
            {
                eau.Play();
                yield return new WaitForSeconds(5f);
                eau.Stop();
                yield return new WaitUntil(() => Players.count > 0);
            }
        }
    }
}

• StartCoroutine(routine) la lance tout de suite jusqu'à son premier yield return. Elle appartient au script : elle s'arrête quand le script est détruit ou échoue.
• yield return null : l'image suivante. new WaitForSeconds(s) : s secondes de l'horloge des scripts. new WaitUntil(condition), new WaitWhile(condition) : vérifiée tout de suite, puis à chaque image. Un autre IEnumerator : le fait tourner à l'intérieur, puis continue. Une autre Coroutine : attend qu'elle finisse. Une Task : attend qu'elle se termine.
• StopCoroutine(coroutine), StopAllCoroutines() : leurs blocs finally tournent.
• Une classe à toi qui dérive de CustomYieldInstruction, avec keepWaiting, attend tant qu'il renvoie true.

WaitForSeconds, WaitUntil, WaitWhile, CustomYieldInstruction et Frame sont dans using Flux;.

Lancer plus tard#

• RunAfter(seconds, action) : lance action après ce nombre de secondes de l'horloge des scripts, tant que le script vit.
• RunAfterFrames(frames, action) : après ce nombre d'images (1 : la suivante).

Les deux renvoient la Coroutine, pour l'arrêter.

Les méthodes async#

async et await marchent : await Frame.Next() reprend la méthode à l'image suivante, et une méthode qui attend une tâche (Task.Run, une requête web) reprend sur le thread principal, là où l'API du monde est permise. Voir threads et asynchrone.

protected override async void Start()
{
    await Frame.Next();
    Debug.Log("Une image plus tard");
}

Les nombres aléatoires#

Random.value (de 0 à 1, les deux compris), Random.Range(min, max) (nombres à virgule : les deux compris ; entiers : max exclu), Random.insideUnitSphere, Random.onUnitSphere, Random.insideUnitCircle, Random.rotation.

Le monde a une seule suite pour tous ses scripts. Random.InitState(seed) la rend identique pour tous les joueurs qui utilisent la même graine : partage une graine dans un état synchronisé ou un événement réseau, et chaque jeu tire le même spectacle.