Utiliser une coroutine avec la méthode d'un autre GameObject ?

[megablast2]

Bonjour a vous,
J'aurais besoin d'un conseil sur les coroutine. Je comprend comment les utiliser temps que tous se passe dans la même classe mais, je ne comprend pas comment les utiliser quand ça se passe dans deux classes. L'une lançant la coroutine et l'autre la méthode a utiliser dedans.

par exemple :

Une class Ennemy :

Code : Tout sélectionner

public class Ennemy : MonoBehaviour
{
    private Transform _transf;
    private Vector3[] _pathArray = new Vector3[]
    { 
        Vector3.zero, 
        new Vector3(10, 0, 0), 
        new Vector3(20, 0, 0), 
        new Vector3(30, 0, 0) 
    };

    private float _speed = 5f;

    private void Awake()
    {
        _transf = transform;
        _transf.position = _pathArray[0];       
    }

    public void MoveTo()
    {
        _transf.position = _pathArray[0];

        int _targetPathIndex = 1;
        Vector3 _targetPath = _pathArray[_targetPathIndex];

        Vector3 _EndPath = _pathArray[3];
 
        while(_transf.position != _EndPath)
        {
            _transf.position = Vector3.MoveTowards(_transf.position, _targetPath, _speed * Time.deltaTime);

            if(_transf.position == _targetPath)
            {
                _targetPathIndex = _targetPathIndex + 1;
                if (_targetPathIndex > 3) break;
                _targetPath = _pathArray[_targetPathIndex];
            }
        }     
    }

Une classe EnnemyManager :

Code : Tout sélectionner

public class EnnemyManager : MonoBehaviour
{
    public Ennemy ennemy;

    private void Update()
    {
        StartCoroutine(EnnemyMove());      
    }

    IEnumerator EnnemyMove()
    {
        ///
    }
}

Comment faire pour que MoveTo de ennemy se lance dans EnnemyManger? A la base j'avais dans Ennemy fait une méthode qui renvoit IEnumerator que je plaçait dans le StartCoroutine de de EnnemyManager mais le mouvement est chaotique.

Code : Tout sélectionner

 public IEnumerator CoroutineMoveTo()
    {
        //start
        _transf.position = _pathArray[0];

        int _targetPathIndex = 1;
        Vector3 _targetPath = _pathArray[_targetPathIndex];

        Vector3 _EndPath = _pathArray[_pathArray.Length - 1];

        while (_transf.position != _EndPath)
        {
            _transf.position = Vector3.MoveTowards(_transf.position, _targetPath, _speed * Time.deltaTime);

            if (_transf.position == _targetPath)
            {
                _targetPathIndex += 1;

                if (_targetPathIndex > 3) break;

                _targetPath = _pathArray[_targetPathIndex];
            }
            yield return null;
        }
    }

Est ce que c'est possible, ou est ce que tout doit se placer dans une seul classe?
Bonne journée,

[boubouk50]

Tu ne peux pas transformer une fonction en coroutine.
Par contre, tu peux appeler une fonction depuis une coroutine.

Il te faut donc placer la boucle dans l'IEnumerator qui appelle la fonction MoveTo ().
Ou bien
que MoveTo () soit un IEnumerator, comme tu le suggères.

Fais tout de même attention, ici, tu appelles une coroutine depuis un Update () ce n'est surement pas le comportement voulu. Aussi, ta boucle dans MoveTo () va tout faire en une seule frame.

[megablast2]

Merci pour ces conseils.

J'ai quand même du mal a voir comment les utiliser si on ne peut pas les mettre dans update. J'avais suivis un tuto ou le programmeur utilise la coroutine pour calculer a la suite le pathfinding de plusieurs personnage pour éviter une surcharge de calcul (je le comprend comme ça du moins). Mais vue qu'il faut le faire dans le start, je vois mal l'intéret.

Tuto request manager

[boubouk50]

la coroutine permet de te substituer à l'Update ().
Tu peux y définir toi même son "timing", des temps d'attentes, un arrêt, un recommencement, etc pour contrôler au mieux le déroulement de ton jeu.
Par ex pour du pathfinding, au lieu de mettre à jour les chemins de tous les marcheurs en même temps à chaque frame (c'est lourd), tu peux le faire en décalé avec une coroutine. Une frame pour le premier, une pour le second, etc pour soulager les calculs (parce qu'il n'y a pas besoin de faire une mise à jour par frame pour du Pathfinding).
C'est aussi faisable dans l'Update () en soi, mais c'est beaucoup plus flexible et adapté.

[megablast2]

A merci, je pense voir un peux mieux comment ça tourne, je vais faire des essai. Il y a le Asyn, que je ne connaissais pas mais qui a l'air plus simple d'utilisation.