Planifier des functions avec InvokeRepeating dans Unity

Unity InvokeRepeating est un mécanisme puissant qui vous permet d’appeler une méthode spécifique dans votre classe à intervalles réguliers, avec ou sans délai. Nous explorerons en détail son utilisation, ses avantages et inconvénients, ainsi que ses alternatives, comme mon autre article sur « Invoke » : Unity Invoke : Exécuter vos méthodes

Table des matières

• Utilisation Standard d’InvokeRepeating
• Amélioration de la Réutilisation du Code
• Annulation d’un Invoke
• InvokeRepeating avec Paramètres (Coroutine)
• Arrêt d’une Coroutine
• InvokeRepeating vs. Coroutine

Utilisation Standard d’InvokeRepeating

InvokeRepeating est facile à utiliser. Vous spécifiez le nom de la fonction à appeler, le délai avant son premier appel en secondes, et l’intervalle entre les appels successifs. Si le délai est réglé à 0, la fonction est exécutée à la fin de la trame actuelle. Notez que même si vous désactivez l’objet après avoir invoqué InvokeRepeating, la fonction continuera d’être appelée jusqu’à ce que l’objet soit détruit.

using UnityEngine;

public class InvokeRepeatingMonoBehaviour : MonoBehaviour
{
    private void Start()
    {
        // Appelez la fonction LaunchMissile dans 3 secondes, puis toutes les 0,3 secondes
        InvokeRepeating("LaunchMissile", 3f, 0.3f);
    }

    private void LaunchMissile()
    {
        // Actions
    }
}

Amélioration de la Réutilisation du Code

Un inconvénient d’InvokeRepeating est qu’il nécessite le nom de la fonction en tant que chaîne, ce qui peut poser problème lors de la refonte de votre code. Une meilleure approche consiste à utiliser « nameof » disponible à partir de C# 6, ce qui garantit une stabilité dans le code.

using UnityEngine;

public class InvokeRepeatingMonoBehaviour : MonoBehaviour
{
    private void Start()
    {
        // Appelez la fonction LaunchMissile dans 3 secondes, puis toutes les 0,3 secondes
        InvokeRepeating(nameof(LaunchMissile), 3f, 0.3f);
    }

    private void LaunchMissile()
    {
        // Actions
    }
}

Annulation d’un Invoke

Pour annuler un Invoke, vous pouvez utiliser la méthode « CancelInvoke ». Vous avez la possibilité d’annuler tous les Invokes ou un Invoke spécifique en utilisant le nom de la fonction ou « nameof ».

private void Cancel()
{
    // Annuler tous les Invokes sur le MonoBehaviour
    CancelInvoke();

    // Annuler uniquement l'Invoke de LaunchMissile
    CancelInvoke(nameof(LaunchMissile));
}

InvokeRepeating avec Paramètres (Coroutine)

Malheureusement, InvokeRepeating ne permet pas de transmettre des arguments à la fonction appelée. Pour cette fonctionnalité, vous devrez utiliser des coroutines. Les coroutines offrent plus de flexibilité et vous permettent de gérer des paramètres.

using System.Collections;
using UnityEngine;

public class InvokeRepeatingCoroutine : MonoBehaviour
{
    private void Start()
    {
        StartCoroutine(LaunchMissile(3f, 0.3f, 5));
    }

    private IEnumerator LaunchMissile(float delay, float interval, int number)
    {
        yield return new WaitForSeconds(delay);

        while (true)
        {
            // Effectuez vos actions

            yield return new WaitForSeconds(interval);
        }
    }
}

Arrêt d’une Coroutine

Pour arrêter une coroutine, il est recommandé d’utiliser « StopCoroutine » en utilisant la référence de la coroutine plutôt que le nom de la fonction ou « nameof ». Cela garantit un meilleur contrôle sur l’arrêt des coroutines.

Vous pouvez également remplacer le while(true) par une condition.

using System.collections;
using UnityEngine;

public class InvokeRepeatingCoroutine : MonoBehaviour
{
    private Coroutine _coroutineLaunchMissile;

    private void Start()
    {
        // Stockez la référence dans une propriété
        _coroutineLaunchMissile = StartCoroutine(LaunchMissile(3f, 0.3f, 5));
    }

    private IEnumerator LaunchMissile(float delay, float interval, int number)
    {
        yield return new WaitForSeconds(delay);

        while (true)
        {
            // Effectuez vos actions

            yield return new WaitForSeconds(interval);
        }
    }

    private void StopCoroutineMissile()
    {
        // Arrêtez toutes les coroutines du MonoBehaviour
        StopAllCoroutines();

        // Arrêtez uniquement une coroutine
        StopCoroutine(_coroutineLaunchMissile);
    }
}

InvokeRepeating vs. Coroutine

Lorsque vous comparez InvokeRepeating aux coroutines, il est important de noter que les coroutines s’arrêtent lorsque l’objet est désactivé ou détruit, contrairement à InvokeRepeating, qui continue de fonctionner tant que l’objet existe.

Les coroutines peuvent être chaînées et offrent une variété de déclarations yield pour répondre à divers cas d’utilisation :

• WaitUntil : Met en pause l’exécution jusqu’à ce qu’une fonction spécifiée ou un délégué renvoie true.
• WaitWhile : L’inverse de WaitUntil.
• WaitForSeconds : Retarde l’exécution pendant un certain nombre de secondes.
• WaitForSecondsRealtime : Retarde en utilisant le temps unscaled.
• WaitForEndOfFrame : Retard se finissant juste avant la fin du rendu de la frame.
• WaitForFixedUpdate : Utile pour la physique.

Pour une compréhension complète des coroutines, veuillez vous référer à la documentation complète d’Unity.

En conclusion, bien qu’InvokeRepeating soit une méthode fonctionnelle pour appeler des fonctions dans Unity, les coroutines offrent un meilleur contrôle et une approche plus robuste pour gérer des scénarios complexes. Envisagez d’adopter les coroutines pour vos projets Unity afin d’améliorer l’efficacité.