Logo du site

Jeu Vidéo 3

Techniques d'intégration multimédia

Coroutines

Qu'est-ce que c'est?

Une Coroutine est un type de fonction qui permet d'étaler l'exécution de code sur plusieurs frames.

Normallement, quand on active une fonction, cette dernière exécute son code en entier avant que le programme principal ne reprenne son cour.

Une Coroutine en contrepartie peut exécuter une portion de son code, retourner le contrôle au programme principal et attendre le prochain frame (ou un temps spécifié) avant de poursuivre sa propre exécution.

Les Coroutines sont particulièment utiles pour déclencher des actions qui doivent s'étaler dans le temps (sur une durée).

Note: Il faut utiliser les Coroutines avec une certaine modération car elles ont un coût en terme de performances comparativement à un code basé principalement sur Update().

Lien utile (vidéo): https://www.tutounity.fr/article.php?id=56

Activer ou arrêter une Coroutine

Pour activer une Coroutine, il suffit de faire appel à la fonction de coroutine avec cette instruction:

StartCoroutine(MaCoroutine());

On peut aussi associer la fonction de coroutine à un champ, afin de pouvoir plus tard arrêter la coroutine au besoin:

private Coroutine _maCoroutine; // référence à ma coroutine
	
void Start()
{
	// on associe la fonction MaCoroutine au champ
	// et on démarre la coroutine
	_maCoroutine = StartCoroutine( MaCoroutine() );
}
	
void Update()
{
	// Si on appuie sur Espace...
	if(Input.GetKeyDown(KeyCode.Space))
	{
		// Arrêt de la coroutine
		StopCoroutine(_maCoroutine); 
	}
}
	
private IEnumerator MaCoroutine()
{
	while(true) // répétition infinie!
	{
		Debug.Log("allo");
			
		// attendre 1/2 seconde puis répéter
		yield return new WaitForSeconds(0.5f);
	}
}

Exemples de Coroutines


Exemple 1: Cette version invoque une coroutine et attend 2 secondes avant d'afficher un message

void Start()
{
    StartCoroutine( AttendreEtAfficher(2.0f) );
}
	
// Au bout de 2 secondes, fait un affichage avec Debug.Log() une seule fois
private IEnumerator AttendreEtAfficher(float nbDeSecondes)
{
    yield return new WaitForSeconds(nbDeSecondes);
    Debug.Log("Temps actuel:  " + Time.time);
}

Exemple 2: Cette version montre comment une coroutine peut s'exécuter à répétition continuellement à chaque 2 secondes

void Start()
{
    StartCoroutine(AttendreEtAfficher(2.0f));
}	

// À chaque 2 secondes, fait un affichage avec Debug.Log()
private IEnumerator AttendreEtAfficher(float nbDeSecondes)
{
    while (true) // boucle infinie!
    {
        yield return new WaitForSeconds(nbDeSecondes);
        Debug.Log("Temps actuel: " + Time.time);
    }
}

Exemple 3: Attendre 5 secondes puis tirer à chaque 2 secondes.

void Start()
{
    StartCoroutine(Tirer());
}
	
private  IEnumerator Tirer() {
     yield return new WaitForSeconds(5f);
 
     while (true)  // boucle infinie!
     {
         Debug.Log("Feu!");
         yield return new WaitForSeconds(2f);
     }
 }

Exemple 4: Afficher un message différent au bout de 3 secondes puis de 6 secondes et enfin une dernière fois 5 secondes plus tard...

void Start()
{
    StartCoroutine(Afficher());
}
	
 private IEnumerator Afficher() {
     yield return new WaitForSeconds(3f);
     Debug.Log("Allo");
     yield return new WaitForSeconds(6f);
     Debug.Log("Salut");
     yield return new WaitForSeconds(5f);
     Debug.Log("Bye");
 }

Exemple 5: Afficher les valeurs d'un tableau une à une, à intervalle de 1 seconde

void Start()
{
    StartCoroutine(Afficher());
}
	
 private IEnumerator Afficher() {
     int[ ] tableau = {1,2,3,4};
     for(int i=0; i<tableau.Length;i++)
     {
	Debug.Log(tableau[i]);
	yield return new WaitForSeconds(1f);
     }
 }

Exemple 6: Afficher un message à chaque frame (La Coroutine agit alors un peu comme un mini-update)

void Start()
{
    StartCoroutine(Afficher());
}
	
private IEnumerator Afficher() {
	while(true)
	{
		Debug.Log("Allo");
		yield return null;
	}
 }