AnimationTrack
*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.
Contrôle la lecture d'une animation sur un Animator. Cet objet ne peut pas être créé, il est plutôt retourné par la méthode Animator:LoadAnimation().
Résumé
Propriétés
L'objet Animation qui a été utilisé pour créer ce AnimationTrack.
Une propriété de lecture seule qui retourne vrai lorsque le AnimationTrack est en train de jouer.
Une propriété de lecture seule qui renvoie la longueur (en secondes) d'un AnimationTrack .Cela retournera 0 jusqu'à ce que l'animation soit entièrement chargée et donc peut ne pas être immédiatement disponible.
Définit si l'animation se répétera après avoir terminé. Si elle est modifiée pendant le jeu, l'effet prendra effet après la fin de l'animation.
Définit la priorité d'un AnimationTrack.Selon ce qui est défini, jouer plusieurs animations à la fois cherchera cette propriété pour déterminer laquelle Class.Keyframe``Class.Pose|Poses devrait être jouée sur l'autre.
La vitesse d'un AnimationTrack est une propriété de lecture seule qui donne la vitesse de lecture actuelle du AnimationTrack .Cela a une valeur par défaut de 1.Lorsque la vitesse est égale à 1, la quantité de temps qu'une animation prend pour se terminer est égale à AnimationTrack.Length (en secondes).
Renvoie la position dans le temps en secondes qu'un AnimationTrack est à travers la lecture de son animationssource.Peut être défini pour faire sauter la piste à un moment spécifique de l'animations.
Propriété de lecture seule qui donne le poids actuel du AnimationTrack . Il a une valeur par défaut de 1.
Propriété de lecture seule qui donne le poids actuel du AnimationTrack .
Méthodes
Modifie le AnimationTrack.Speed d'une animations. Une valeur positive pour la vitesse joue l'animation en avant, une valeur négative la joue en arrière, et 0 l'arrête.
Change le poids d'une animations, avec le paramètre facultatif fadeTime qui détermine la durée pendant laquelle AnimationTrack.WeightCurrent atteint AnimationTrack.WeightTarget.
Retourne un event qui se déclenche lorsqu'un KeyframeMarker spécifié a été touché dans un animation .
Renvoie la position temporelle du premier Keyframe du nom donné dans un AnimationTrack .
Joue le AnimationTrack . Une fois appelé, un AnimationTrack jouera avec le temps de fondu, le poids et la vitesse spécifiés.
Arrête le AnimationTrack.
Évènements
Se déclenche lorsqu'un AnimationTrack boucles sur la prochaine mise à jour suivant la fin du cycle d'animation précédent.
S'enflamme lorsque le AnimationTrack est complètement terminé de déplacer quoi que ce soit dans le monde.L'animation a fini de jouer, la « disparition » est terminée et le sujet est dans une position neutre.
Se déclenche chaque fois que la lecture d'un AnimationTrack atteint un Keyframe qui n'a pas le nom par défaut - "Keyframe".
S'enflamme lorsque le AnimationTrack finit de jouer.La piste d'animation peut toujours animer le sujet alors que l'animation "disparaît".Pour capturer quand la piste d'animation est complètement terminée en déplaçant quoi que ce soit dans le monde, utilisez l'événement AnimationTrack.Ended.
Propriétés
Animation
L'objet Animation qui a été utilisé pour créer ce AnimationTrack.Pour créer un AnimationTrack , vous devez charger un objet Animation sur un Animator en utilisant la méthode Animator:LoadAnimation().
Échantillons de code
L'exemple de code suivant imprime le nom d'une animation chaque fois qu'une AnimationTrack joue sur un Humanoid.Ce script peut être placé dans un modèle avec un enfant Humanoid .
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
animator.AnimationPlayed:Connect(function(animationTrack)
local animationName = animationTrack.Animation.Name
print("Animation playing " .. animationName)
end)IsPlaying
Une propriété de lecture seule qui retourne vrai lorsque le AnimationTrack est en train de jouer.
Cette propriété peut être utilisée par les développeurs pour vérifier si une animation est déjà en train de jouer avant de la jouer (car cela la ferait redémarrer).Si un développeur souhaite obtenir tout le jeu AnimationTracks sur un Animator ou un Humanoid, il devrait utiliser Animator:GetPlayingAnimationTracks()
Échantillons de code
Cet exemple de code inclut une fonction simple qui jouera une piste d'animation si elle n'est pas en train de jouer, ou ajustera autrement sa vitesse et son poids pour correspondre aux nouveaux paramètres donnés.
local function playOrAdjust(animationTrack, fadeTime, weight, speed)
if not animationTrack.IsPlaying then
animationTrack:Play(fadeTime, weight, speed)
else
animationTrack:AdjustSpeed(speed)
animationTrack:AdjustWeight(weight, fadeTime)
end
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playOrAdjust(animationTrack, 1, 0.6, 1)Length
Une propriété de lecture seule qui renvoie la longueur (en secondes) d'un AnimationTrack .Cela retournera 0 jusqu'à ce que l'animation soit entièrement chargée et donc peut ne pas être immédiatement disponible.
Lorsque le AnimationTrack.Speed d'un AnimationTrack est égal à 1, l'animation prendra AnimationTrack.Length (en secondes) pour se terminer.
Échantillons de code
La fonction suivante jouera une piste d'animation pour une durée spécifique.Cela se fait en changeant la vitesse de l'animation en la longueur de l'animation divisée par la durée de lecture souhaitée.Cela pourrait être utilisé dans des situations où un développeur souhaite jouer une animation standard pendant une durée différente (par exemple, recharger différentes capacités).
local function playAnimationForDuration(animationTrack, duration)
local speed = animationTrack.Length / duration
animationTrack:Play()
animationTrack:AdjustSpeed(speed)
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765000"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playAnimationForDuration(animationTrack, 3)Looped
Cette propriété détermine si l'animation se répétera après avoir terminé.Si elle est modifiée pendant le jeu, la modification prendra effet après la fin de l'animation.
La propriété Looped pour AnimationTrack par défaut à la façon dont elle a été définie dans l'éditeur d'animation.Cependant, cette propriété peut être modifiée, ce qui permet de contrôler le AnimationTrack pendant que le jeu est en cours d'exécution.Looped gère également correctement les animations jouées en arrière (négatives AnimationTrack.Speed ).Après que la première clé ait été atteinte, elle redémarrera à la dernière image-clé.
Cette propriété permet au développeur d'avoir une variante de boucle et de non boucle de la même animations, sans avoir à télécharger deux versions sur Roblox.
Échantillons de code
L'animation dans cet exemple s'exécute normalement en boucle.Une fois le joueur et l'animation chargés, l'animation est jouée d'une manière non bouclée, puis d'une manière bouclée.
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
while not localPlayer.Character do
task.wait()
end
local character = localPlayer.Character
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507770453"
local animationTrack = animator:LoadAnimation(animation)
animationTrack.Looped = false
task.wait(3)
animationTrack:Play()
task.wait(4)
animationTrack.Looped = true
animationTrack:Play()La fonction dans cet exemple de code jouera une piste d'animation sur une boucle, pour un nombre spécifique de boucles, avant d'arrêter l'animation.
Dans certains cas, le développeur peut vouloir arrêter une animation en boucle après un certain nombre de boucles terminées, plutôt qu'après un certain temps.C'est là que l'événement DidLoop peut être utilisé.
local function playForNumberLoops(animationTrack, number)
animationTrack.Looped = true
animationTrack:Play()
local numberOfLoops = 0
local connection = nil
connection = animationTrack.DidLoop:Connect(function()
numberOfLoops = numberOfLoops + 1
print("loop: ", numberOfLoops)
if numberOfLoops >= number then
animationTrack:Stop()
connection:Disconnect() -- il est important de couper les connexions lorsqu'elles ne sont plus nécessaires
end
end)
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playForNumberLoops(animationTrack, 5)Priority
Cette propriété définit la priorité d'un AnimationTrack .Selon ce qui est défini, jouer plusieurs animations à la fois cherchera cette propriété pour déterminer laquelle Class.Keyframe``Class.Pose|Poses devrait être jouée sur l'autre.
La propriété priorité pour par défaut à la façon dont elle a été définie et publiée dans l'éditeur d'animation de Studio .Il utilise Enum.AnimationPriority qui a 7 niveaux de priorité :
- Action4 (priorité la plus élevée)
- Action3
- Action2
- Action
- Mouvement
- Inactif
- Cœur (priorité la plus basse)
Définir correctement les priorités d'animation, soit via l'éditeur, soit via cette propriété, permet de jouer plusieurs animations sans qu'elles ne se heurtent.Lorsque deux animations de jeu dirigent la cible pour déplacer la même extrémité de manière différente, l'AnimationTrack avec la plus haute priorité s'affichera.Si les deux animations ont la même priorité, les poids des pistes seront utilisés pour combiner les animations.
Cette propriété permet également au développeur de jouer la même animation à différentes priorités, sans avoir à télécharger de nouvelles versions sur Roblox.
Speed
La vitesse d'un AnimationTrack est une propriété de lecture seule qui donne la vitesse de lecture actuelle du AnimationTrack .Cela a une valeur par défaut de 1.Lorsque la vitesse est égale à 1, la quantité de temps qu'une animation prend pour se terminer est égale à AnimationTrack.Length (en secondes).
Si la vitesse est ajustée, alors le temps réel qu'il faudra pour jouer une piste peut être calculé en divisant la longueur par la vitesse.La vitesse est une quantité sans unité.
La vitesse peut être utilisée pour lier la durée d'une animation à différents événements de jeu (par exemple, recharger une capacité) sans avoir à télécharger différentes variantes de la même animations.
Cette propriété est seulement lue et vous pouvez la modifier en utilisant AnimationTrack:AdjustSpeed().
Échantillons de code
Dans cet exemple, un joueur et une animation sont chargés.La longueur d'une piste d'animation détermine la durée de la piste si la vitesse est à 1.Si la vitesse est ajustée, alors le temps réel qu'il faudra pour jouer une piste peut être calculé en divisant la longueur par la vitesse.
local ContentProvider = game:GetService("ContentProvider")
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
while not localPlayer.Character do
task.wait()
end
local character = localPlayer.Character
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507770453"
ContentProvider:PreloadAsync({ animation })
local animationTrack = animator:LoadAnimation(animation)
local normalSpeedTime = animationTrack.Length / animationTrack.Speed
animationTrack:AdjustSpeed(3)
local fastSpeedTime = animationTrack.Length / animationTrack.Speed
print("At normal speed the animation will play for", normalSpeedTime, "seconds")
print("At 3x speed the animation will play for", fastSpeedTime, "seconds")La fonction suivante jouera une piste d'animation pour une durée spécifique.Cela se fait en changeant la vitesse de l'animation en la longueur de l'animation divisée par la durée de lecture souhaitée.Cela pourrait être utilisé dans des situations où un développeur souhaite jouer une animation standard pendant une durée différente (par exemple, recharger différentes capacités).
local function playAnimationForDuration(animationTrack, duration)
local speed = animationTrack.Length / duration
animationTrack:Play()
animationTrack:AdjustSpeed(speed)
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765000"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playAnimationForDuration(animationTrack, 3)TimePosition
Renvoie la position dans le temps en secondes qu'un AnimationTrack est à travers la lecture de son animationssource.Peut être défini pour faire sauter la piste à un moment spécifique de l'animations.
La position dans le temps peut être définie pour aller à un point spécifique de l'animations, mais le AnimationTrack doit être en train de jouer pour le faire.Il peut également être utilisé en combinaison avec AnimationTrack:AdjustSpeed() pour geler l'animation à un point souhaité (en définissant la vitesse à 0).
Échantillons de code
L'exemple de code suivant inclut deux fonctions qui montrent comment AdjustSpeed et TimePosition peuvent être utilisés pour geler une animation à un point spécifique.
La première fonction gèle une animation à un point donné dans le temps (défini en secondes).Le deuxième gèle à un pourcentage (entre 0 ou 100) en multipliant le pourcentage par la longueur de la piste.
Comme TimePosition ne peut pas être utilisé lorsqu'une piste d'animation n'est pas en train de jouer, les fonctions vérifient que l'animation est en train de jouer avant de procéder.
function freezeAnimationAtTime(animationTrack, timePosition)
if not animationTrack.IsPlaying then
-- Jouez l'animation si elle ne joue pas
animationTrack:Play()
end
-- Réglez la vitesse à 0 pour geler l'animation
animationTrack:AdjustSpeed(0)
-- Sauter à la position de temps désirée
animationTrack.TimePosition = timePosition
end
function freezeAnimationAtPercent(animationTrack, percentagePosition)
if not animationTrack.IsPlaying then
-- Jouez l'animation si elle ne joue pas
animationTrack:Play()
end
-- Réglez la vitesse à 0 pour geler l'animation
animationTrack:AdjustSpeed(0)
-- Sauter à la position de temps désirée
animationTrack.TimePosition = (percentagePosition / 100) * animationTrack.Length
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
freezeAnimationAtTime(animationTrack, 0.5)
freezeAnimationAtPercent(animationTrack, 50)WeightCurrent
Lorsque le poids est défini dans un AnimationTrack, il ne change pas instantanément mais se déplace de WeightCurrent à AnimationTrack.WeightTarget.Le temps qu'il faut pour le faire est déterminé par le paramètre fadeTime donné lorsque l'animation est jouée, ou le poids est ajusté.
WeightCurrent peut être vérifié contre AnimationTrack.WeightTarget pour voir si le poids souhaité a été atteint.Notez que ces valeurs ne doivent pas être vérifiées pour l'égalité avec l'opérateur ==, car ces deux valeurs sont des flottants.Pour voir si WeightCurrent a atteint le poids cible, il est recommandé de vérifier si la distance entre ces valeurs est suffisamment petite (voir échantillon de code ci-dessous).
Le système de pondération des animations est utilisé pour déterminer comment les AnimationTracks jouant à la même priorité sont mélangés ensemble.Le poids par défaut est un, et aucun mouvement ne sera visible sur un AnimationTrack avec un poids de zéro.La pose qui est montrée à tout moment est déterminée par la moyenne pondérée de tous les Poses et le poids actuel de chacun AnimationTrack .Dans la plupart des cas, les animations de mélange ne sont pas requises et l'utilisation de AnimationTrack.Priority est plus appropriée.
Échantillons de code
Cet exemple de code charge deux animations sur le Humanoïde du joueur local et démontre comment le paramètre fadeTime dans AnimationTrack.Play détermine la durée nécessaire pour que le poids d'une piste d'animation atteigne son objectif de poids.
Comme WeightCurrent et WeightTarget sont des flottants, l'opérateur == ne peut pas être utilisé pour comparer, il est plutôt approprié de vérifier que la différence entre eux est suffisamment petite pour assumer que la disparition du poids est terminée.
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
while not localPlayer.Character do
task.wait()
end
local character = localPlayer.Character
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animation1 = Instance.new("Animation")
animation1.AnimationId = "rbxassetid://507770453"
local animation2 = Instance.new("Animation")
animation2.AnimationId = "rbxassetid://507771019"
task.wait(3) -- temps d'attente arbitraire pour permettre au personnage de tomber en place
local animationTrack1 = animator:LoadAnimation(animation1)
local animationTrack2 = animator:LoadAnimation(animation2)
animationTrack1.Priority = Enum.AnimationPriority.Movement
animationTrack2.Priority = Enum.AnimationPriority.Action
animationTrack1:Play(0.1, 5, 1)
animationTrack2:Play(10, 3, 1)
local done = false
while not done and task.wait(0.1) do
if math.abs(animationTrack2.WeightCurrent - animationTrack2.WeightTarget) < 0.001 then
print("got there")
done = true
end
endWeightTarget
AnimationTrack.WeightTarget est une propriété de lecture seule qui donne le poids actuel du AnimationTrack.Il a une valeur par défaut de 1 et est défini lorsque AnimationTrack:Play() , AnimationTrack:Stop() ou AnimationTrack:AdjustWeight() est appelé.Lorsque le poids est défini dans un AnimationTrack il ne change pas instantanément mais se déplace de WeightCurrent à AnimationTrack.WeightTarget.Le temps qu'il faut pour le faire est déterminé par le paramètre fadeTime donné lorsque l'animation est jouée, ou le poids est ajusté.
WeightCurrent peut être vérifié contre AnimationTrack.WeightTarget pour voir si le poids souhaité a été atteint.Notez que ces valeurs ne doivent pas être vérifiées pour l'égalité avec l'opérateur ==, car ces deux valeurs sont des flottants.Pour voir si WeightCurrent a atteint le poids cible, il est recommandé de vérifier si la distance entre ces valeurs est suffisamment petite (voir échantillon de code ci-dessous).
Le système de pondération des animations est utilisé pour déterminer comment les AnimationTracks jouant à la même priorité sont mélangés ensemble.Le poids par défaut est un, et aucun mouvement ne sera visible sur un AnimationTrack avec un poids de zéro.La pose qui est montrée à tout moment est déterminée par la moyenne pondérée de tous les Poses et le poids actuel de chacun AnimationTrack .Dans la plupart des cas, les animations de mélange ne sont pas requises et l'utilisation de AnimationTrack.Priority est plus appropriée.
Échantillons de code
Cet exemple de code charge deux animations sur le Humanoïde du joueur local et démontre comment le paramètre fadeTime dans AnimationTrack.Play détermine la durée nécessaire pour que le poids d'une piste d'animation atteigne son objectif de poids.
Comme WeightCurrent et WeightTarget sont des flottants, l'opérateur == ne peut pas être utilisé pour comparer, il est plutôt approprié de vérifier que la différence entre eux est suffisamment petite pour assumer que la disparition du poids est terminée.
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
while not localPlayer.Character do
task.wait()
end
local character = localPlayer.Character
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animation1 = Instance.new("Animation")
animation1.AnimationId = "rbxassetid://507770453"
local animation2 = Instance.new("Animation")
animation2.AnimationId = "rbxassetid://507771019"
task.wait(3) -- temps d'attente arbitraire pour permettre au personnage de tomber en place
local animationTrack1 = animator:LoadAnimation(animation1)
local animationTrack2 = animator:LoadAnimation(animation2)
animationTrack1.Priority = Enum.AnimationPriority.Movement
animationTrack2.Priority = Enum.AnimationPriority.Action
animationTrack1:Play(0.1, 5, 1)
animationTrack2:Play(10, 3, 1)
local done = false
while not done and task.wait(0.1) do
if math.abs(animationTrack2.WeightCurrent - animationTrack2.WeightTarget) < 0.001 then
print("got there")
done = true
end
endMéthodes
AdjustSpeed
Cette fonction modifie le AnimationTrack.Speed d'une animations.Une valeur positive pour la vitesse joue l'animation en avant, une négative la joue en arrière, et 0 la met en pause.
La vitesse initiale d'une piste d'animation est définie comme un paramètre dans AnimationTrack:Play() .Cependant, la vitesse d'une piste peut être modifiée pendant la lecture, en utilisant AdjustSpeed.Lorsque la vitesse est égale à 1, la quantité de temps qu'une animation prend pour se terminer est égale à AnimationTrack.Length (en secondes).
Quand est ajusté, le temps réel qu'il faudra pour qu'une piste soit jouée peut être calculé en divisant la longueur par la vitesse. La vitesse est une quantité sans unité.
La vitesse peut être utilisée pour lier la durée d'une animation à différents événements de jeu (par exemple, recharger une capacité) sans avoir à télécharger différentes variantes de la même animations.
Paramètres
La vitesse de lecture de l'animation doit être modifiée.
Retours
Échantillons de code
La fonction suivante jouera une piste d'animation pour une durée spécifique.Cela se fait en changeant la vitesse de l'animation en la longueur de l'animation divisée par la durée de lecture souhaitée.Cela pourrait être utilisé dans des situations où un développeur souhaite jouer une animation standard pendant une durée différente (par exemple, recharger différentes capacités).
local function playAnimationForDuration(animationTrack, duration)
local speed = animationTrack.Length / duration
animationTrack:Play()
animationTrack:AdjustSpeed(speed)
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765000"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playAnimationForDuration(animationTrack, 3)Dans cet exemple, un joueur et une animation sont chargés.La longueur d'une piste d'animation détermine la durée de la piste si la vitesse est à 1.Si la vitesse est ajustée, alors le temps réel qu'il faudra pour jouer une piste peut être calculé en divisant la longueur par la vitesse.
local ContentProvider = game:GetService("ContentProvider")
local Players = game:GetService("Players")
local localPlayer = Players.LocalPlayer
while not localPlayer.Character do
task.wait()
end
local character = localPlayer.Character
local humanoid = character:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507770453"
ContentProvider:PreloadAsync({ animation })
local animationTrack = animator:LoadAnimation(animation)
local normalSpeedTime = animationTrack.Length / animationTrack.Speed
animationTrack:AdjustSpeed(3)
local fastSpeedTime = animationTrack.Length / animationTrack.Speed
print("At normal speed the animation will play for", normalSpeedTime, "seconds")
print("At 3x speed the animation will play for", fastSpeedTime, "seconds")AdjustWeight
Change le poids d'une animations, avec le paramètre facultatif fadeTime qui détermine la durée pendant laquelle AnimationTrack.WeightCurrent atteint AnimationTrack.WeightTarget.
Lorsque le poids est défini dans un AnimationTrack, il ne change pas instantanément mais se déplace de WeightCurrent à AnimationTrack.WeightTarget.Le temps qu'il faut pour le faire est déterminé par le paramètre fadeTime donné lorsque l'animation est jouée, ou le poids est ajusté.
WeightCurrent peut être vérifié contre AnimationTrack.WeightTarget pour voir si le poids souhaité a été atteint.Notez que ces valeurs ne doivent pas être vérifiées pour l'égalité avec l'opérateur ==, car ces deux valeurs sont des flottants.Pour voir si WeightCurrent a atteint le poids cible, il est recommandé de vérifier si la distance entre ces valeurs est suffisamment petite (voir échantillon de code ci-dessous).
Le système de pondération des animations est utilisé pour déterminer comment les AnimationTracks jouant à la même priorité sont mélangés ensemble.Le poids par défaut est un, et aucun mouvement ne sera visible sur un AnimationTrack avec un poids de zéro.La pose qui est montrée à tout moment est déterminée par la moyenne pondérée de tous les Poses et le poids actuel de chacun AnimationTrack .Voir ci-dessous pour un exemple de fusion d'animation en pratique.Dans la plupart des cas, les animations de mélange ne sont pas requises et l'utilisation de AnimationTrack.Priority est plus appropriée.
Paramètres
Le poids que l'animation doit être modifié.
La durée du temps pendant lequel l'animation disparaîtra entre le poids ancien et le nouveau poids pour.
Retours
Échantillons de code
Cet exemple de code inclut une fonction qui change le poids d'une piste d'animation et produit jusqu'à ce que le poids ait changé en poids cible nouveau.
L'objectif de cet exemple est de montrer comment le paramètre fadeTime d'AnimationTrack.AdjustWeight fonctionne.Dans la plupart des cas, si un développeur souhaite abandonner le temps de fondu, il est recommandé qu'il utilise wait(fadeTime).
local function changeWeight(animationTrack, weight, fadeTime)
animationTrack:AdjustWeight(weight, fadeTime)
local startTime = tick()
while math.abs(animationTrack.WeightCurrent - weight) > 0.001 do
task.wait()
end
print("Time taken to change weight " .. tostring(tick() - startTime))
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
changeWeight(animationTrack, 0.6, 1)GetMarkerReachedSignal
Cette fonction renvoie une event similaire à l'événement AnimationTrack.KeyframeReached, sauf qu'elle ne se déclenche que lorsqu'un événement spécifié KeyframeMarker a été frappé dans un animation .La différence permet une plus grande maîtrise du moment où l'événement se lancer.
Pour en savoir plus sur l'utilisation de cette fonction, voir événements d'animation dans l'article éditeur d'animation.
Voir aussi :
Paramètres
Le nom du signal KeyframeMarker est en cours de création. Ne pas le confondre avec le nom du Keyframe.
Retours
Le signal créé et tiré lorsque l'animation atteint le créé KeyframeMarker. À ne pas confondre avec le nom du Keyframe.
Échantillons de code
This LocalScript code waits for the local player's Humanoid object to load, then it creates a new Animation instance with the proper Animation.AnimationId. The animation is then loaded onto the humanoid, creating an AnimationTrack, and the track is played with AnimationTrack:Play(). Following that, the AnimationTrack:GetMarkerReachedSignal() function detects when the "KickEnd" marker is hit.
local Players = game:GetService("Players")
local player = Players.LocalPlayer
local character = player.Character or player.Character:Wait()
local humanoid = character:WaitForChild("Humanoid")
-- Create new "Animation" instance
local kickAnimation = Instance.new("Animation")
-- Set its "AnimationId" to the corresponding animation asset ID
kickAnimation.AnimationId = "rbxassetid://2515090838"
-- Load animation onto the humanoid
local kickAnimationTrack = humanoid:LoadAnimation(kickAnimation)
-- Play animation track
kickAnimationTrack:Play()
-- If a named event was defined for the animation, connect it to "GetMarkerReachedSignal()"
kickAnimationTrack:GetMarkerReachedSignal("KickEnd"):Connect(function(paramString)
print(paramString)
end)GetTimeOfKeyframe
Renvoie la position temporelle du premier Keyframe du nom donné dans un AnimationTrack .Si plusieurs Keyframes partagent le même nom, il retournera le plus ancien dans l'animations.
Cette fonction renverra une erreur si elle est utilisée avec un nom de cadre clé non valide (celui qui n'existe pas par exemple) ou si le sous-jacent Animation n'a pas encore été chargé.Pour résoudre ce problème, assurez-vous que seuls les noms de cadre clé corrects sont utilisés et que l'animation a été chargée avant d'appeler cette fonction.
Pour vérifier si l'animation a été chargée, vérifiez que le AnimationTrack.Length est supérieur à zéro.
Paramètres
Retours
Échantillons de code
Cet échantillon inclut une fonction qui sautera au premier keyframe d'un nom spécifié dans une piste d'animation.
Comme AnimationTrack.TimePosition ne peut pas être défini pendant que l'animation n'est pas en train de jouer la fonction, vérifiez d'abord si l'animation est en train de jouer.
Cet exemple ne fonctionnera que lorsqu'une animation aura été chargée.
local function jumpToKeyframe(animationTrack, keyframeName)
local timePosition = animationTrack:GetTimeOfKeyframe(keyframeName)
if not animationTrack.IsPlaying then
animationTrack:Play()
end
animationTrack.TimePosition = timePosition
end
local ANIMATION_ID = 0
local KEYFRAME_NAME = "Test"
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://" .. ANIMATION_ID
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
jumpToKeyframe(animationTrack, KEYFRAME_NAME)Play
Lorsque AnimationTrack:Play() est appelé, l'animation de la piste commencera à jouer et le poids de l'animation augmentera de 0 à la poids spécifié (défaut de 1) au cours du temps de fondu de spécifié (défaut de 0.1).
La vitesse à laquelle le AnimationTrack jouera est déterminée par le paramètre de vitesse (défaut de 1).Lorsque la vitesse est égale à 1, le nombre de secondes que la piste prendra pour se terminer est égal à la propriété de la piste AnimationTrack.Length.Par exemple, une vitesse de 2 provoquera que la piste se joue deux fois plus rapidement.
Le poids et la vitesse de l'animation peuvent également être modifiés après que l'animation ait commencé à jouer en utilisant les méthodes AnimationTrack:AdjustWeight() et AnimationTrack:AdjustSpeed().
Si le développeur veut démarrer l'animation à un point spécifique en utilisant AnimationTrack.TimePosition, il est important que l'animation soit jouée avant que cela soit fait.
Paramètres
La durée du temps au cours de laquelle le poids de l'animationsdevrait disparaître.
Le poids de l'animation à jouer.
La vitesse de lecture de l'animations.
Retours
Échantillons de code
La fonction suivante jouera une piste d'animation pour une durée spécifique.Cela se fait en changeant la vitesse de l'animation en la longueur de l'animation divisée par la durée de lecture souhaitée.Cela pourrait être utilisé dans des situations où un développeur souhaite jouer une animation standard pendant une durée différente (par exemple, recharger différentes capacités).
local function playAnimationForDuration(animationTrack, duration)
local speed = animationTrack.Length / duration
animationTrack:Play()
animationTrack:AdjustSpeed(speed)
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765000"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playAnimationForDuration(animationTrack, 3)L'exemple de code suivant inclut deux fonctions qui montrent comment AdjustSpeed et TimePosition peuvent être utilisés pour geler une animation à un point spécifique.
La première fonction gèle une animation à un point donné dans le temps (défini en secondes).Le deuxième gèle à un pourcentage (entre 0 ou 100) en multipliant le pourcentage par la longueur de la piste.
Comme TimePosition ne peut pas être utilisé lorsqu'une piste d'animation n'est pas en train de jouer, les fonctions vérifient que l'animation est en train de jouer avant de procéder.
function freezeAnimationAtTime(animationTrack, timePosition)
if not animationTrack.IsPlaying then
-- Jouez l'animation si elle ne joue pas
animationTrack:Play()
end
-- Réglez la vitesse à 0 pour geler l'animation
animationTrack:AdjustSpeed(0)
-- Sauter à la position de temps désirée
animationTrack.TimePosition = timePosition
end
function freezeAnimationAtPercent(animationTrack, percentagePosition)
if not animationTrack.IsPlaying then
-- Jouez l'animation si elle ne joue pas
animationTrack:Play()
end
-- Réglez la vitesse à 0 pour geler l'animation
animationTrack:AdjustSpeed(0)
-- Sauter à la position de temps désirée
animationTrack.TimePosition = (percentagePosition / 100) * animationTrack.Length
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
freezeAnimationAtTime(animationTrack, 0.5)
freezeAnimationAtPercent(animationTrack, 50)SetTargetInstance
Paramètres
Retours
Stop
Arrête le AnimationTrack.Une fois appelé, le poids de l'animation se déplacera vers zéro au fil du temps spécifié par le paramètre facultatif fadeTime optionnel.Par exemple, si Stop() est appelé avec un fadeTime de 2 , il faudra deux secondes pour que le poids de la piste atteigne zéro et ses effets se terminercomplètement.Veuillez noter que ce sera le cas, indépendamment du poids initial de l'animations.
Il n'est pas recommandé d'utiliser un fadeTime de 0 dans une tentative d'annuler cet effet et de mettre fin à l'animation immédiatement pour Motor6Ds ceux qui ont leur Motor.MaxVelocity défini à zéro, car cela fait geler les jointures en emplacement.Si elle doit se terminer immédiatement, assurez-vous que le Motor.MaxVelocity de Motor6Ds dans votre rig est suffisamment élevé pour qu'ils s'accrochent correctement.
Paramètres
Le temps, en secondes, pour lequel le poids de l'animation doit être estompé.
Retours
Échantillons de code
Cet exemple de code inclut une fonction qui arrête une piste d'animation avec un temps de fondu spécifique et produit jusqu'à ce que la transition soit terminée et que le poids de la piste d'animation soit égal à zéro.
L'objectif de cet exemple est de montrer comment le paramètre fadeTime d'AnimationTrack.Stop fonctionne.Dans la plupart des cas, si un développeur souhaite abandonner le temps de fondu, il est recommandé qu'il utilise wait(fadeTime).
local function fadeOut(animationTrack, fadeTime)
animationTrack:Stop(fadeTime)
local startTime = tick()
while animationTrack.WeightCurrent > 0 do
task.wait()
end
local timeTaken = tick() - startTime
print("Time taken for weight to reset: " .. tostring(timeTaken))
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
animationTrack:Play()
fadeOut(animationTrack, 1)Évènements
DidLoop
Cet événement se déclenche chaque fois qu'une boucle AnimationTrack bouclée termine une boucle, lors de la prochaine mise à jour.
Actuellement, il peut également tirer à la fin exacte d'une piste d'animation non bouclée, mais ce comportement ne doit pas être utilisé.
Échantillons de code
La fonction dans cet exemple de code jouera une piste d'animation sur une boucle, pour un nombre spécifique de boucles, avant d'arrêter l'animation.
Dans certains cas, le développeur peut vouloir arrêter une animation en boucle après un certain nombre de boucles terminées, plutôt qu'après un certain temps.C'est là que l'événement DidLoop peut être utilisé.
local function playForNumberLoops(animationTrack, number)
animationTrack.Looped = true
animationTrack:Play()
local numberOfLoops = 0
local connection = nil
connection = animationTrack.DidLoop:Connect(function()
numberOfLoops = numberOfLoops + 1
print("loop: ", numberOfLoops)
if numberOfLoops >= number then
animationTrack:Stop()
connection:Disconnect() -- il est important de couper les connexions lorsqu'elles ne sont plus nécessaires
end
end)
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
playForNumberLoops(animationTrack, 5)Ended
S'enflamme lorsque le AnimationTrack est complètement terminé de déplacer quoi que ce soit dans le monde.L'animation a fini de jouer, la « disparition » est terminée et le sujet est dans une position neutre.
Vous pouvez l'utiliser pour agir lorsque le sujet de la piste d'animation est de retour dans une position neutre qui n'est pas affectée par le AnimationTrack ou pour nettoyer le AnimationTrack .ou toute connexion associée.
Échantillons de code
La fonction dans cet exemple de code joue une animationTrack et produit jusqu'à ce qu'elle s'arrête et se termine, imprimant à chaque étape du chemin.
local InsertService = game:GetService("InsertService")
local Players = game:GetService("Players")
-- Créer un modèle NPC pour animer.
local npcModel = Players:CreateHumanoidModelFromUserId(129687796)
npcModel.Name = "JoeNPC"
npcModel.Parent = workspace
npcModel:MoveTo(Vector3.new(0, 15, 4))
local humanoid = npcModel:WaitForChild("Humanoid")
-- Charger une animation.
local animationModel = InsertService:LoadAsset(2510238627)
local animation = animationModel:FindFirstChildWhichIsA("Animation", true)
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
-- Se connecter à l'événement arrêté. Cela se déclenche lorsque l'animation s'arrête de
-- c'est son propre accord, ou nous appelons explicitement Stop.
animationTrack.Stopped:Connect(function()
print("Animation stopped")
end)
-- Se connecter à l'événement terminé. Cela se déclenche lorsque l'animation est complètement
-- fini d'affecter le monde. Dans ce cas, il tirera 3 secondes
-- après avoir appelé animationTrack:Stop parce que nous passons dans un 3
-- deuxième fondu.
animationTrack.Ended:Connect(function()
print("Animation ended")
animationTrack:Destroy()
end)
-- Exécutez, donnez-lui un peu à jouer, puis arrêtez.
print("Calling Play")
animationTrack:Play()
task.wait(10)
print("Calling Stop")
animationTrack:Stop(3)KeyframeReached
Il se déclenche chaque fois que la lecture d'un AnimationTrack atteint un Keyframe qui n'a pas le nom par défaut - "Keyframe".
Cet événement permet à un développeur d'exécuter du code à des points prédéfinis dans une animation (définis par Keyframe noms).Cela permet d'étendre la fonctionnalité par défaut des animations Roblox en ajoutant Sounds ou ParticleEffects à différents points dans une animation.
Keyframe les noms n'ont pas besoin d'être uniques.Par exemple, si une animation a trois keyframes nommés « Particles », l'événement KeyframeReached se déclenchera chaque fois qu'un de ces keyframes sera atteint.
Keyframe les noms peuvent être définis dans l'éditeur d'animation Roblox lors de la création ou de l'édition d'une animations.Cependant, elles ne peuvent pas être définies par un Script sur une animation existante avant de la jouer.
Paramètres
Stopped
S'enflamme chaque fois que la AnimationTrack finit de jouer.
Cet événement a plusieurs utilisations.Il peut être utilisé pour attendre jusqu'à ce qu'un AnimationTrack ait cessé avant de continuer (par exemple, si vous chaînez une série d'animations pour jouer après les unes les autres).Il peut également être utilisé pour nettoyer tout Instances créé pendant la lecture de l'animation.
Échantillons de code
La fonction dans cet exemple de code jouera une animationTrack et produira jusqu'à ce qu'elle s'arrête, avant d'imprimer.
local function yieldPlayAnimation(animationTrack, fadeTime, weight, speed)
animationTrack:Play(fadeTime, weight, speed)
animationTrack.Stopped:Wait()
print("Animation has stopped")
end
local animation = Instance.new("Animation")
animation.AnimationId = "rbxassetid://507765644"
local humanoid = script.Parent:WaitForChild("Humanoid")
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
yieldPlayAnimation(animationTrack, 1, 0.6, 1)