Éditeur de Graphiques d'Animation

L'Éditeur de Graphiques d'Animation est un outil visuel basé sur des nœuds qui permet aux artistes techniques et aux animateurs de construire une logique d'animation complexe directement dans Roblox Studio. En fournissant une interface simplifiée pour créer des comportements comme des arbres de fusion, il élimine la dépendance traditionnelle au script manuel pour le mouvement des personnages.

Ce système fonctionne en tandem avec votre flux de travail d'animation existant :

• Éditeur d'Animation : Continuez à utiliser l'Éditeur d'Animation comme votre outil principal pour la création de clips individuels et l'affinement des keyframes et des courbes.
• Éditeur de Graphiques d'Animation : Utilisez ce nouvel espace de travail pour prendre ces clips et les organiser en un arbre logique pour générer des comportements de jeu sophistiqués.

Conçu pour améliorer la collaboration, le graphique visuel permet aux développeurs d'inspecter, de déboguer et de comprendre rapidement la logique créée par les animateurs. Tandis que les artistes se concentrent sur le raffinement du mouvement interactif, les développeurs peuvent toujours accéder aux nœuds du graphique d'animation de manière programmatique pour un contrôle direct sur les animations et les états mélangés.

Construire un graphique

Pour commencer à construire la logique d'un personnage animable, accédez à l'éditeur de graphiques d'animation via l'onglet Avatar dans le ruban de Studio. Les étapes suivantes montrent comment initialiser un rig et construire un réseau de nœuds de base en utilisant les animations par défaut de marche et de salutation.

Pour une exploration plus approfondie des applications pratiques, vous pouvez consulter le Fichier de Référence de Graphiques d'Animation, qui contient à la fois des exemples d'implémentation fondamentaux et complexes.

Pour créer votre propre graphique d'animation, similaire à l'exemple de base fourni dans la référence, suivez les étapes suivantes :

1. Dans Studio, ajoutez un rig animable en naviguant vers l'onglet Avatar et en sélectionnant Personnage ⟩ Mon Avatar.

   

2. Ouvrez l'éditeur de graphiques d'animation en naviguant vers Éditeur de Graphiques dans l'onglet Avatar.

   

3. Sélectionnez le rig animable dans le viewport 3D et sélectionnez Créer un Graphique.

4. Dans l'éditeur de graphiques, faites un clic droit et sélectionnez Clip.

   

5. Dans le nouveau nœud Clip, définissez l'ID d'Animation.

   1. Sélectionnez le menu déroulant ID d'Animation.

   2. Pour soumettre un ID d'actif d'animation spécifique, cliquez sur Importer.

      

   3. Dans le champ ID d'Animation, ajoutez l'animation de marche par défaut : 507777826.

   4. Sélectionnez Importer.

6. Ajoutez un autre nœud clip en répétant les étapes 4-5 en utilisant l'animation de salutation par défaut : 507770239.

   

7. Dans l'éditeur de graphiques, faites un clic droit et sélectionnez Ajouter.

   

8. Connectez les nœuds Clip au nœud Ajouter en faisant glisser le connecteur de sortie en haut à droite vers le port approprié :

   1. Connectez le nœud Clip avec l'animation de marche au port Base.
   2. Connectez le nœud Clip avec l'animation de salutation au port Additif.

   

9. Du nœud Ajouter, connectez le connecteur de sortie en haut à droite au port de sortie de graphique Pose.

   

10. (Optionnel) Assignez un paramètre à votre variable Vitesse.

    1. Cliquez et faites glisser le port de Vitesse vert vers une zone vide. Un nouveau nœud paramètre s'affiche.

       

    2. En haut à gauche de l'éditeur de graphiques, utilisez le panneau de paramètres pour modifier rapidement les paramètres de vos nœuds. Vous pouvez également y accéder programmatique.

       

11. Testez l'animation en appuyant sur le bouton de lecture.

    

12. Essayez de tester différents poids, vitesses, modes de lecture, et d'autres animations. Pour plus d'informations sur les nœuds individuels, voir la référence de nœud.

Intégration API

La création et le déploiement d'un Graphique d'Animation suivent le pipeline d'animation standard de Roblox. Après avoir sélectionné un rig dans l'éditeur de graphiques d'animation, un nouvel actif AnimationGraphDefinition est créé. Cet actif sert de conteneur pour vos nœuds, connexions et paramètres. Une fois votre logique finalisée, vous publiez le graphique pour obtenir un ID d'Actif standard.

Dans vos scripts, vous interagissez avec ces graphiques en les chargeant sur un Animator comme vous le feriez avec une animation traditionnelle. Pour activer la logique interne du graphique, utilisez AnimationTrack:SetParameter() pour passer des valeurs en temps réel—comme la vitesse de mouvement ou les booléens d'état—directement dans les variables du graphique.

local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://123456789" -- Votre ID de Graphique Publié

local animationTrack = animator:LoadAnimation(animation)
animationTrack:Play()

-- Mises à jour dynamiques des paramètres via RunService
game:GetService("RunService").Stepped:Connect(function(_, dt)
    local currentSpeed = humanoidRootPart.AssemblyLinearVelocity.Magnitude
    animationTrack:SetParameter("humanoidSpeed", currentSpeed)
end)

Référence des nœuds

Chaque nœud de graphique d'animation sert de porte logique ou de source de données qui traite les données d'animation avant qu'elles n'atteignent le rig du personnage. Cette section fournit une décomposition technique des blocs fonctionnels dans l'éditeur de graphiques d'animation. Tous les nœuds sortent actuellement une pose d'animation.

Chaque section de nœud comprend :

• Définition – Un résumé de l'objectif et du rôle du nœud au sein du graphique.
• Entrées – Les flux de données entrant dans le nœud. Plusieurs entrées sont représentées comme Input1, Input2, ..., InputN.
• Propriétés d'entrée – Paramètres directement liés à une entrée spécifique (une entrée Idle assignée à une Position de 0.5 sur un nœud Blend1D).
• Données d'événement – Événements émis ou consommés par le nœud pour déclencher la logique interne du graphique ou des scripts Luau externes. Ce comportement peut changer au cours du développement bêta.

Règles d'événement globales

Pour tous les nœuds et transitions, les règles suivantes s'appliquent par défaut :

• Les événements se propagent vers le haut depuis leur nœud source à travers le graphique. Chaque événement porte un poids représentant l'influence de sa source dans le mélange final. Si le poids atteint zéro à un moment donné, l'événement est silencieux.
• Les nœuds sans logique d'événement personnalisée transmettent tous les événements sans changement ; les nœuds qui mélangent ou sélectionnent entre les entrées peuvent réduire le poids ou bloquer les événements provenant d'entrées non primaires (voir section Événement par nœud).
• Les événements de marqueur qui atteignent le sommet du graphique peuvent être observés via AnimationTrack:GetMarkerReachedSignal().

Clip

Une référence à un actif AnimationClip. Cela sert de nœud terminal dans le graphique, générant les données d'animation brutes qui alimentent d'autres nœuds pour le mélange, la sélection ou la modification.

Entrées

• Aucune

Propriétés

Propriété	Type	Description
Clip	ID d'Actif	L'actif d'animation à jouer (par exemple, rbxassetid://12345).
ModeDeLecture	Enum.AnimationNodePlayMode	Définit le comportement du clip une fois qu'il atteint la fin de sa durée. Boucle (défaut) : Redémarre automatiquement depuis le début une fois que le clip est terminé. PingPong : Joue du début à la fin, puis joue immédiatement à l'envers du fin au début. UneFoisEtMaintien : Joue une fois et maintient la pose finale à l'achèvement. UneFoisEtRéinitialise : Joue une fois et revient à la pose de départ initiale à l'achèvement.
Inverse	Booléen	Contrôle la direction de la lecture.
Vitesse	Nombre	Un multiplicateur pour le taux de lecture. 0.0 met le graphique sur pause, 1.0 est la vitesse normale, et 2.0 est deux fois plus rapide.
Couper	Booléen	Active ou désactive le troncature de la durée du clip.
TrimStart	Nombre	Les horodatages absolus (en secondes) où la lecture doit commencer.
TrimEnd	Nombre	Les horodatages absolus (en secondes) où la lecture doit se terminer.

Données d'événement

• Gestion des événements : Aucune. Ceci est un nœud terminal sans enfants.
• Émission d'événements : Lit des marqueurs personnalisés intégrés dans le clip d'animation (par exemple, "Pas", "BalancementD'Arme") et les émet en tant qu'événements nommés à la trame précise où ils se produisent. Si le clip est tronqué, seuls les marqueurs à l'intérieur de l'intervalle défini [TrimStart, TrimEnd] (inclus) sont émis.

Sélectionner

Sélectionne entre n'importe quel nombre d'entrées via la propriété Sélection. Chaque fois que la sélection actuelle change, elle déclenche une nouvelle transition.

Entrées

• Entrée1...EntréeN

Propriétés

Propriété	Type	Description
Sélection	Chaîne	L'ID unique de l'entrée à sélectionner, correspondant au nom de la connexion d'entrée (par exemple, "Marche").

Données d'événement

• Gestion des événements : Les événements de l'entrée actuellement sélectionnée passent avec leur poids inchangé.
• Émission d'événements : Ne transmet que les événements de l'entrée actuellement sélectionnée. Pendant une transition, l'émission d'événements suit les règles d'événements globaux.

SélectionPrioritaire

Évalue une liste d'entrées connectées de haut en bas et joue la première dont la condition est évaluée comme vraie. Cela permet une sélection d'animation hiérarchique basée sur une logique spécifique. Chaque fois que la sélection actuelle change, elle déclenche une nouvelle transition.

Entrées

• Entrée1...EntréeN

  • Déclencheur (Booléen) : Une condition logique qui doit être vraie pour que cette entrée soit activée. Dans les versions actuelles, cela est relié à un paramètre booléen.
  • Interruptible (Enum.AnimationNodeInterruptible) : Définit la règle pour savoir quand cette animation active peut être interrompue par une entrée de priorité supérieure.

    • Toujours (défaut) : L'entrée peut être interrompue à tout moment par une condition de priorité supérieure.
    • Terminé : L'animation actuelle doit terminer sa lecture avant qu'une entrée de priorité supérieure puisse prendre le relais.
    • Déclencheur : L'entrée n'est interrompable que lorsque le InterruptibleTrigger est défini sur vrai.
  • DéclencheurInterruptible (Booléen) : Disponible uniquement si Interruptible est défini sur Déclencheur. L'entrée peut être interrompue lorsque cette expression spécifique est vraie.

Propriétés

Propriété	Type	Description
DefaultInterruptible	Enum.AnimationNodeInterruptible	La règle d'interruption de base appliquée à toutes les entrées. Chaque entrée peut remplacer cela par sa propre propriété d'entrée Interruptible.
DefaultInterruptibleTrigger	Booléen	La valeur de déclenchement de base utilisée lorsqu'une entrée résolue a son mode Interruptible défini sur Déclencheur. Chaque entrée peut remplacer cela par sa propre propriété d'entrée InterruptibleTrigger.

Données d'événement

• Gestion des événements : Les événements de l'entrée actuellement sélectionnée passent avec leur poids inchangé.
• Émission d'événements : Ne transmet que les événements de l'entrée actuellement sélectionnée. Pendant une transition, l'émission d'événements suit les règles d'événements globaux.

Séquence

Active les entrées connectées dans un ordre séquentiel spécifique basé sur des conditions d'attente définies. Chaque fois que la sélection actuelle change, elle déclenche une nouvelle transition.

Entrées

• Entrée1...EntréeN

  • AttendrePour (Enum.AnimationNodeWaitFor) : Spécifie la condition qui doit être remplie avant que la séquence passe à l'entrée suivante.

    • Terminé (défaut) : Avance vers l'entrée suivante lorsque l'entrée actuelle termine un cycle. Le comportement de l'avancement dépend de l'entrée connectée :

      • Clip à jouer une fois : Avance lorsque le clip se termine.
      • Clip en boucle : Avance après qu'une boucle complète est terminée.
      • Séquence avec boucles infinies : Avance après un cycle complet à travers toutes les entrées.
      • Séquence avec boucles infinies : Avance après que toutes les boucles sont complètes.
    • Déclencher : Active la prochaine entrée lorsque une expression logique personnalisée évalue à vrai.
  • AttendrePourDéclencheur (Booléen) : Disponible uniquement lorsque WaitFor est défini sur Déclencher.

Propriétés

Propriété	Type	Description
LoopCount	Nombre	Le nombre de fois à parcourir l'ensemble de la séquence (le défaut est 1). Une valeur de 0 indique une boucle infinie. Une fois le nombre atteint, le nœud respecte le réglage de boucle ou de maintien de la dernière entrée.
DefaultWaitFor	Enum.AnimationNodeWaitFor	La condition d'attente de base appliquée à toutes les entrées. Chaque entrée peut remplacer cela par sa propre propriété d'entrée WaitFor.

Données d'événement

• Gestion des événements : Les événements de l'entrée actuellement active passent avec leur poids inchangé.
• Émission d'événements : Ne transmet que les événements de l'entrée actuellement active dans la séquence. Pendant une transition, l'émission d'événements suit les règles d'événements globaux.

SéquenceAléatoire

Sélectionne et joue une de ses entrées connectées au hasard. Lorsque l'animation actuellement sélectionnée se termine, le nœud choisit aléatoirement une autre entrée à jouer. Assignez à chaque entrée un poids spécifique pour influencer la probabilité de sa sélection. Chaque fois que la sélection actuelle change, elle déclenche une nouvelle transition.

Entrées

• Entrée1...EntréeN

  • Poids (Nombre) : Détermine la probabilité de cette entrée étant sélectionnée ; des poids plus élevés augmentent la chance de sélection.

Propriétés

Propriété	Type	Description
PlayCount	Nombre	Le nombre d'entrées que le nœud jouera avant de s'arrêter. Une fois atteint, le nœud respecte le réglage de boucle ou de maintien de la dernière entrée. Le défaut est 0 pour infini.
Graine	Nombre	Une valeur utilisée pour initialiser le Générateur de Nombres Aléatoires (GNA), garantissant que la séquence reste cohérente entre différents clients. Défaut à -1 pour la graine aléatoire.

Données d'événement

• Gestion des événements : Les événements de l'entrée actuellement active passent avec leur poids inchangé.
• Émission d'événements : Ne transmet que les événements de l'entrée actuellement active dans la séquence. Pendant une transition, l'émission d'événements suit les règles d'événements globaux.

Sur

Superpose la pose Sur à la pose de Base. Lorsqu'il est combiné avec un nœud Masque, les articulations masquées dans la pose Sur révèlent entièrement la pose de Base, créant un effet de superposition transparent.

Entrées

• Base : La couche d'arrière-plan ou du bas, typiquement une animation en corps entier comme locomotion ou un état inactif.
• Sur : La couche de premier plan ou du haut à appliquer sur la base, comme une animation de geste de main ou d'utilisation d'outil.

Propriétés

Propriété	Type	Description
Poids	Nombre	Le poids de mélange utilisé pour atténuer la pose Sur. Par défaut, il est 1.0 (pleine surcharge) et n'est pas limité.

Données d'événement

• Gestion des événements :

  • Le nœud écoute les événements des entrées Base et Sur.
• Émission d'événements :

  • Événements de Base : Tous les événements de l'entrée de Base sont passés sans modification.
  • Événements de Sur : Les événements de l'entrée Sur sont ajustés par la propriété Poids.

    • À Poids 0.5, les événements Sur se propagent à moitié poids.
    • À Poids 0, ils sont silencieux.

Ajouter

Ajoute la pose Additive à la pose Base, atténuée par un Poids spécifique (non limité).

Entrées

• Base : La pose d'animation principale.
• Additif : La pose à superposer à la base.

Propriétés

Propriété	Type	Description
Poids	Nombre	Détermine la force de la pose additive appliquée à la base.

Données d'événement

• Gestion des événements : Le nœud écoute les événements des entrées Base et Additif.
• Émission d'événements : Tous les événements des entrées Base et Additive sont passés sans modification.

Soustraire

Convertit une animation en une pose additive en soustrayant une pose de base relative de la pose cible ($A - B$). Le résultat est atténué par un Poids spécifique (non limité).

Entrées

• A : La pose d'animation cible.
• B : La pose de base relative à soustraire.

Propriétés

Propriété	Type	Description
Poids	Nombre	Détermine la force de l'effet de soustraction appliqué au résultat.

Données d'événement

• Gestion des événements : Le nœud écoute les événements des deux Entrées A et B.
• Émission d'événements : Tous les événements des deux entrées A et B sont passés sans modification.

Mélange1D

Interpolé linéairement entre les deux poses d'animation les plus proches de la position d'entrée actuelle sur un seul axe.

Entrées

• Entrée1...EntréeN

  • Position (Nombre) : La coordonnée spécifique pour chaque entrée subséquente sur l'axe de mélange.

Propriétés

Propriété	Type	Description
Position	Nombre	La valeur active actuelle sur l'axe de mélange utilisée pour échantillonner les animations. Si Position est en dehors de la plage des positions d'entrée définies, le nœud extrapole en utilisant les deux entrées les plus proches.
PhaseSync	Enum.AnimationNodePhaseSync	Configure si le timing des entrées enfants doit être synchronisé. Synchronisé (défaut) : Synchronisation normalisée. Le nœud calcule une "durée virtuelle" basée sur la moyenne pondérée des entrées actives. Chaque nœud d'entrée ajuste son étape de temps pour que tous les enfants convergent vers la même phase, gardant les animations de longueurs différentes en synchronisation. Non synchronisé : Mélange standard où les clips avancent indépendamment à leurs propres taux de lecture.

Données d'événement

• Gestion des événements : Le nœud écoute les événements de tous les nœuds enfants actuellement actifs.
• Émission d'événements : Seuls les événements de l'entrée active ayant le poids le plus élevé se propagent, scalés par leur poids de mélange. Les événements de l'entrée secondaire sont réduits au silence.

Mélange2D

Mélange plusieurs poses d'animation ensemble en fonction de deux paramètres d'entrée dans un espace de coordonnées 2D. Cela généralise le nœud Mélange1D pour gérer des scénarios complexes, tels que le mélange en fonction à la fois de la direction de mouvement et de la vitesse simultanément.

Entrées

• Entrée1...EntréeN

  • X (Nombre) : La coordonnée X pour chaque entrée subséquente.
  • Y (Nombre) : La coordonnée Y pour chaque entrée subséquente.

Propriétés

Propriété	Type	Description
ModeD'Entrée	Enum.AnimationNodeBlend2DInputMode	Définit le système de coordonnées utilisé pour évaluer l'espace de fusion : Cartésien (défaut) : Utilise des coordonnées de grille 2D standard. X et Y représentent la position actuelle dans l'espace de fusion. Polaire : Utilise des valeurs angulaires et de magnitude. X représente la direction en radians, tandis que Y représente la magnitude ou la force de mouvement. La direction est pondérée plus lourdement que la magnitude, donc les entrées à des angles similaires mais avec des magnitudes différentes se mélangent plus facilement que celles à des angles différents.
X	Nombre	La coordonnée X actuelle (cartésien) ou la Direction en radians (polaire).
Y	Nombre	La coordonnée Y actuelle (cartésien) ou Magnitude (polaire).
PhaseSync	Enum.AnimationNodePhaseSync	Configure si le timing des entrées enfants doit être synchronisé. Synchronisé (défaut) : Synchronisation normalisée. Le nœud calcule une "durée virtuelle" basée sur la moyenne pondérée des entrées actives. Chaque nœud d'entrée ajuste son étape de temps pour que tous les enfants convergent vers la même phase, gardant les animations de longueurs différentes en synchronisation. Non synchronisé : Mélange standard où les clips avancent indépendamment à leurs propres taux de lecture.

Données d'événement

• Gestion des événements : Le nœud écoute les événements de tous les nœuds enfants actuellement actifs.
• Émission d'événements : Seuls les événements de l'entrée active ayant le poids le plus élevé se propagent, scalés par leur poids de mélange. Les événements de l'entrée secondaire sont réduits au silence.

Masque

Applique un masque prédéfini à la Pose d'entrée. Un masque est défini par un poids par objet (par exemple, articulation) dans la hiérarchie du rig, permettant un contrôle précis ou "dégradé" de l'animation.

Entrées

• Pose : La pose d'animation à masquer.

Propriétés

Propriété	Type	Description
Masque	ObjectValue	Un ObjectValue (créé comme enfant direct de la définition de Nœud d'Animation Masque) qui définit les poids de masque. Il peut fonctionner de deux manières : Directement : Le ObjectValue lui-même contient des attributs mappant les noms d'objets de rig à des valeurs de poids spécifiques. Par Référence : Le ObjectValue fait référence à une autre Instance qui contient les attributs de mappage. Cela permet des masques partagés à travers différents nœuds dans le graphique. Lors de la création d'un masque, vous pouvez choisir un schéma de rig (HumanoidRigDescription ou Picker) pour peupler la hiérarchie. HumanoidRigDescription : Standardise le masque pour les personnages humanoïdes. Picker : Permet à l'utilisateur de sélectionner n'importe quel rig spécifique dans l'espace de travail pour peupler la hiérarchie du masque.
Inverser	Booléen	Lorsque vrai, applique les valeurs de poids comme 1 - poids. Cela permet d'utiliser un masque de manière inverse sans créer un nouvel actif.

Données d'événement

• Gestion des événements : Le nœud écoute tous les événements de l'entrée Pose.
• Émission d'événements : Tous les événements de l'entrée Pose sont passés sans modification.

Vitesse

Modifie le taux de lecture d'une pose d'animation entrante.

Entrées

• Pose : La pose d'animation ou le sous-graphique dont la vitesse de lecture sera modifiée.

Propriétés

Propriété	Type	Description
Vitesse	Nombre	Un multiplicateur appliqué à l'intervalle de temps ($dt$). 0.0 met le graphique sur pause, 1.0 est la vitesse normale, et 2.0 est deux fois plus rapide.

Données d'événement

• Gestion des événements : Le nœud écoute les événements de l'entrée Pose.
• Émission d'événements : Tous les événements de l'entrée Pose sont passés sans modification. Notez que bien que la vitesse de lecture visuelle change, le timing des événements émis (tels que les marqueurs) s'ajustera en conséquence avec le taux de lecture modifié.

SortieGraphique

Représente la dernière pose évaluée du graphique. Ce nœud est automatiquement inclus dans tous les nouveaux graphiques de l'éditeur de graphiques d'animation. Sa présence garantit que le graphique est toujours valide et produit de manière constante une pose d'animation.

Entrées

• Pose : Les données d'animation finales à appliquer au rig.

Propriétés

• Aucune

Données d'événement

• Gestion des événements : Le nœud écoute tous les événements passés à travers l'entrée connectée finale.
• Émission d'événements : Ce nœud sert de point de sortie pour le pipeline d'animation et n'émet pas de signaux vers le graphique.

Transitions

Plusieurs nœuds dans le graphique d'animation (comme Sélectionner, SélectionPrioritaire, Séquence, et SéquenceAléatoire) gèrent comment les animations se mélangent lors du passage entre les entrées actives. Pour éviter la redondance dans la référence de nœud, ces comportements sont définis par des groupes de propriétés de transition standardisés.

Transition par défaut

Le comportement de mélange de base appliqué au nœud chaque fois qu'il passe à une nouvelle entrée active.

• DefaultTransitionDuration (nombre) : Le temps (en secondes) qu'il faut pour mélanger complètement dans la nouvelle pose.
• DefaultTransitionCurve (Enum.PoseEasingStyle) : La fonction d'assouplissement appliquée pendant le mélange. Actuellement, ne prend en charge que Enum.PoseEasingStyle.Linear et Enum.PoseEasingStyle.CubicV2.

Surcharge de transition

Propriétés de lien spécifiques aux entrées qui remplacent la transition par défaut. Celles-ci sont appliquées lorsque le nœud effectue une transition vers cette entrée spécifique.

• TransitionOverrideDuration (nombre) : Remplace la durée de transition par défaut.
• TransitionOverrideCurve (Enum.PoseEasingStyle) : Remplace la courbe de transition par défaut. Actuellement, ne prend en charge que Enum.PoseEasingStyle.Linear et Enum.PoseEasingStyle.CubicV2.

Réplication

Les paramètres de graphique d'animation sont locaux à chaque AnimationTrack et ne sont pas répliqués automatiquement. Cela peut changer dans de futures mises à jour, mais l'approche actuellement recommandée utilise :

• Client → Serveur : Un RemoteEvent pour envoyer des paramètres du client propriétaire au serveur à un taux de tick fixe.
• Serveur → Autres Clients : Attributs d'Instance qui se répliquent automatiquement vers tous les clients.

Personnages des joueurs

Un script client drive les personnages des joueurs. Étant donné que seul le client propriétaire connaît l'état de gameplay actuel (entrée de mouvement, état humanoïde, etc.), les paramètres doivent circuler du client propriétaire au serveur, puis à tous les autres clients.

Configuration

Sous StarterCharacterScripts, créez :

• Un LocalScript pour l'animation côté client et le pilotage de paramètres.
• Un Script pour la réplication côté serveur.
• Un RemoteEvent pour la communication client-serveur.

Script client

Le client propriétaire gouverne les paramètres des événements de gameplay et les envoie au serveur périodiquement. Les autres clients lisent les attributs répliqués à partir du script serveur à la place.

local Players = game:GetService("Players")
local RunService = game:GetService("RunService")

local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:FindFirstChildOfClass("Animator") or humanoid

-- Charger le graphique d'animation
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://YOUR_GRAPH_ID" -- Remplacez par votre ID de graphique publié
local track = animator:LoadAnimation(animation)
track:Play()

local isLocalCharacter = Players:GetPlayerFromCharacter(character) == Players.LocalPlayer

if not isLocalCharacter then
    -- Lire les paramètres répliqués à partir du script serveur
    local animateServer = script.Parent:WaitForChild("AnimateServer")

    for attribute, value in animateServer:GetAttributes() do
        track:SetParameter(attribute, value)
    end

    animateServer.AttributeChanged:Connect(function(attribute)
        track:SetParameter(attribute, animateServer:GetAttribute(attribute))
    end)
    return
end

-- Joueur local : piloter les paramètres à partir de l'état humanoïde
local params = {}

local function setParam(key, value)
    track:SetParameter(key, value)
    params[key] = value
end

-- Exemple : piloter les paramètres à partir de l'état humanoïde
humanoid.Running:Connect(function(speed)
    setParam("Vitesse", speed)
    setParam("État", if speed < 0.1 then "Inactif" else "EnMouvement")
end)

-- Envoyer des paramètres au serveur à un taux de tick fixe
local replicateEvent = script.Parent:WaitForChild("ReplicateEvent")
local TICK_RATE = 1 / 20
local lastSendTime = 0

RunService.Stepped:Connect(function(gameTime)
    if gameTime - lastSendTime > TICK_RATE then
        lastSendTime = gameTime
        replicateEvent:FireServer(params)
    end
end)

Script serveur

Reçoit des paramètres du client propriétaire, gère le graphique d'animation côté serveur et propage les valeurs en tant qu'attributs pour la réplication aux autres clients.

local Players = game:GetService("Players")

local character = script.Parent
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:FindFirstChildOfClass("Animator") or humanoid

-- Charger le même graphique d'animation sur le serveur
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://YOUR_GRAPH_ID" -- Même ID de graphique que le client
animation.Parent = script
local track = animator:LoadAnimation(animation)
track:Play()

-- Recevoir les paramètres du client propriétaire et répliquer via des attributs
local replicateEvent = script.Parent:WaitForChild("ReplicateEvent")

replicateEvent.OnServerEvent:Connect(function(player, params)
    if Players:GetPlayerFromCharacter(character) ~= player then
        return
    end

    for key, value in params do
        track:SetParameter(key, value)
        script:SetAttribute(key, value)
    end
end)

NPCs

Puisque le serveur possède l'animation des PNJ, seule la réplication serveur-client est nécessaire. Gérez le graphique d'animation sur le serveur, écrivez les paramètres comme attributs sur un script serveur, et lisez-les sur les clients en utilisant le même motif Instance.AttributeChanged montré ci-dessus.

Latence

Les autres clients voient les animations avec un petit délai égal à l'intervalle de tick (jusqu'à 50 ms à 20 Hz) plus la latence réseau. Vous pouvez réduire l'intervalle de tick en augmentant la fréquence (comme 1/30), au coût d'un trafic réseau plus élevé. 20 Hz est un défaut raisonnable ; le mélange d'animations est suffisamment indulgent pour que de petits retards soient difficiles à remarquer.