Discussion :

[wearelegion]

Bonjour à toutes et tous.

Voilà quelques semaines que j'ai décidé de me former à l'UE4 et de tenter de réaliser un premier et modeste projet de jeu.

Aujourd'hui, pour la première fois, je rencontre un os que je ne parviens pas à résoudre seul, ni avec l'aide des multiples tutos et sujets épluchés sur le net (français et anglais).
J'ai donc l'espoir que quelqu'un sache m'éclairer de son expérience, ici, sur ce qui me pose problème aujourd'hui.

Alors voici la situation, assez simple sur le papier :
Je souhaite déclencher, en début d'un niveau (branchement sur un eventbeginplay), la mise en mouvement d'une multitude d'instances d'un même static mesh, mais de façon désynchronisée.
Le mouvement est très simple et correspond simplement à la modification de l'altitude de chacune de ces instances avec déplacement simple selon Z (X et Y verrouillés).

Evidemment, si l'on oublie la volonté de désynchroniser le déclenchement de ces déplacements pour chaque instance, réaliser une telle animation ne me pose pas de problème. De même, s'il s'agissait de déclencher ces déplacements en boucle, instance après instance, cela ne poserait pas de problème non plus.

Cependant le rendu que je désire atteindre est de déclencher la mise en mouvement de ces instances ni en simultanée, ni non plus l'une après l'autre mais un peu comme le décollage de plusieurs fusées aléatoirement déclenchées dans une range de délai spécifiée.
Ainsi, cela revient à vouloir lancer une deuxième fusée (donc un second déplacement) alors que le premier est encore en cours. Et ceci pour un certain nombre de fusée (plusieurs dizaines).



Voici le code tel que je comprends bien qu'il ne peut pas fonctionner, ou tout du moins pas comme je le souhaite. Ici la timeline est lue en "updatant" l'ensemble des "locations" des différents instances sélectionnées aléatoirement parmi le pool spécifié. En d'autres termes, car je crains de ne pas être très clair, l'ensemble du déplacement total Z déclenché par la timeline se répartit aléatoirement sur l'ensemble des instances.

Je crois comprendre, à présent que je cerne un peu mieux le node timeline, qu'il est juste impossible d'en utiliser une seule pour animer en désynchronisés plusieurs instances de mon mesh puisque lancer une nouvelle animation coupera immédiatement le flux de sortie de l'animation déjà en cours. Il semble donc obligatoire d'attendre que chaque animation soit achevée pour en déclencher une nouvelle...

Ma question finale est donc la suivante : Suis-je obligé de créer un même code adapté autant de fois que nécessaire pour chacune de mes instances (96 à l'heure actuelle o_O') ou existe-t-il une fonction ou une technique qui permette de réaliser l'équivalent d'une timeline mais qui enverrait un flux indépendant chaque fois qu'on lui en demande un supplémentaire ?

Certes, une demande copieuse en lécture, mais j'essaye de me montrer suffisamment clair pour ne pas vous faire perdre votre temps à devoir déchiffrer la demande... mais ça n'est peut-être pas encore gagné

Quoi qu'il en soit, merci pour le temps que vous pourrez m'accorder sur ce sujet.
Et bonne année à toutes et tous.

[Bousk]

À froid avec cette image pour référence
- tu n'exécutes pas pour chaque entité mais pour une entité au hasard parmi toutes
- le play animation a plusieurs entrées, mais tu n'utilieses que Play from Start
En particulier, il y a Play et SetNewTime qui, au feeling, permettraient d'assigner une durée déjà écoulée, et donc de modifier où l'animation en est, puis de démarrer l'animation à partir de ce point. Et c'est la valeur de ce timer qu'il faut rendre random pour qu'ils bougent différemment.

[wearelegion]

Bonsoir Bousk.

Avant toute autre chose, merci d'avoir pris le temps de me répondre.

Je me rends compte que j'ai peut-être manqué de précision.

Je sais bien que le morceau de code présenté dans mon précédent message ne se réfère qu'à une unique instance. Je n'ai pas fait apparaître de système de boucle volontairement pour ne pas rendre difficile à lire le principe.
Et en réalité, pour être tout à fait précis, le code tel qu'il apparaît dans l'image agit comme ceci : Il déclenche la timeline qui va retourner une valeur croissante de Z de 0 à 500 sur une durée de 2 sec (cela n’apparaît bien sur pas ici mais je le précise pour que tout soit parfaitement limpide). La chose un peu contre-intuitive, et qui est bonne à savoir dans l'absolue, c'est que la pin de sortie "update" fonctionne comme un flux continu qui appelle en permanence la valeur de "new track" donc du node "getactorlocation" dont l'instance correspondante est à chaque appel renouvelée par la fonction "random". Du coup, pour info, dans un tel montage, ça n'est pas à une seule instance que s'applique cette ascension en Z, mais à une proportion aléatoire de l'ensemble des instances du pool possédant le tag "Colonne". A chaque micro-variation de Z envoyée par le flux de la timeline, cette micro-variation s'applique à l'une des instances aléatoirement choisie du pool.

Toute cette précision n'a que peu d’intérêt vis-à-vis de mon problème mais je trouve que c'est une info qu'il peut être intéressant de connaitre.

Pour le reste, je tiens à préciser que je comprends l'ensemble des options de cette fonction timeline, et le fonctionnement de ses entrées/sorties. Là n'est pas vraiment la difficulté. Et sur ce point tes précisions sont exactes.

Mais mon problème ne se situe pas là.
En fait, si je crée une boucle sur une seule et même timeline, chaque fois que cette timeline est appelée pour déclencher le déplacement d'une nouvelle instance, le flux précédemment envoyé sur une première instance est stoppé alors que je souhaiterais qu'elle puisse se poursuivre jusqu'à la fin malgré ce nouvel appel. A priori, cette fonction timeline ne permet pas de gérer plusieurs déplacements simultanément s'ils ne sont pas synchronisés.
Car bien sur je peux facilement coder de manière à diriger le flux de l'update vers une multitude des instances possédant le tag "colonne", mais alors les déplacements seront synchronisés : mêmes déplacements en même temps.

Je souhaite en quelque sorte trouver une méthode pour réaliser l'action d'une fonction timeline mais qui aurait l'option multi-tâche et qui serait donc capable d'envoyer et gérer autant de flux que requis sans qu'ils s'interrompent les uns les autres.

Est-ce plus clair ainsi ? Aurais-tu une piste en tête ?

J'image cela une dernière fois : Imaginons qu'à t=0 je fais décoller une fusée n°1, son animation d'ascension doit durer 5 sec, puis à t=1sec, donc pendant que la fusée continue de suivre son flux de déplacement, je fais décoller une fusée n°2, qui va opérer la même partition de déplacement, puis une fusée n°3 à t=1,3 sec, qui en fait de même, etc...
La fonction timeline ne permet pas, dans l'état, d'obtenir ce genre de résultat, puisqu'un nouvel appel coupe le flux du précédent.

Merci encore pour l'aide apportée.