AnimationTrack

Afficher les obsolètes

*Ce contenu est traduit en utilisant l'IA (Beta) et peut contenir des erreurs. Pour consulter cette page en anglais, clique ici.

Création impossible

Contrôle la lecture d'une animation sur un AnimationController. Ce objet ne peut pas être créé, mais il est retourné par la méthode Animator:LoadAnimation().

Résumé

Propriétés

  • Animation:Animation
    Lecture uniquement
    Non répliqué
    Lecture parallèle

    L'objet Animation qui a été utilisé pour créer ce AnimationTrack .

  • IsPlaying:bool
    Lecture uniquement
    Non répliqué
    Lecture parallèle

    Une propriété de lecture qui renvoie vrai quand la AnimationTrack joue.

  • Length:number
    Lecture uniquement
    Non répliqué
    Lecture parallèle

    Une propriété de lecture qui renvoie la longueur (en secondes) d'une AnimationTrack . Ce sera renvoyé 0 jusqu'à ce que l'animation soit entièrement chargée et donc ne peut pas être immédiatement disponible.

  • Looped:bool
    Lecture parallèle

    Définit si l'animation se répétera après la fin. Si elle est modifiée pendant que vous jouez, l'animation prendra effet après la fin de l'animation.

  • Priority:Enum.AnimationPriority
    Lecture parallèle

    Définit la priorité d'un AnimationTrack. Selon ce que ce paramètre est défini, le jouer plusieurs animations à la fois regardera à cette propriété pour déterminer lequel Keyframe, et Poses devra être joué sur l'un l'autre.

  • Speed:number
    Lecture uniquement
    Non répliqué
    Lecture parallèle

    La vitesse d'une AnimationTrack est une propriété de lecture qui donne la vitesse de lecture actuelle de la AnimationTrack. Ce paramètre a une valeur par défaut de 1. Lorsque la vitesse est égale à 1, le temps de chargement d'une animation est équivalant à AnimationTrack.Length (en secondes).

  • TimePosition:number
    Non répliqué
    Lecture parallèle

    Renvoie la position à temps en secondes dans lesquelles un AnimationTrack est en jouant son animationssource. Peut être réglé pour sauter la piste à un moment spécifique dans l'animations.

  • WeightCurrent:number
    Lecture uniquement
    Non répliqué
    Lecture parallèle

    Propriété de lecture qui donne le poids actuel de la AnimationTrack. Il a une valeur par défaut de 1.

  • WeightTarget:number
    Lecture uniquement
    Non répliqué
    Lecture parallèle

    Propriété de lecture qui donne le poids actuel de la AnimationTrack.

Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Méthodes

Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Évènements

Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Propriétés

Animation

Animation
Lecture uniquement
Non répliqué
Lecture parallèle

L'objet Animation qui a été utilisé pour créer ce AnimationTrack . Pour créer un AnimationTrack, vous devez charger un objet 1> Class.Animation1> sur un 4> Class.Animator:LoadAnimation()4> en utilisant la méthode 7> Class.Animator:LoadAnimation()

Échantillons de code

Listen For New Animations
local function listenForNewAnimations(humanoid)

	humanoid.AnimationPlayed:Connect(function(animationTrack)

		local animationName = animationTrack.Animation.Name

		print("Animation playing " .. animationName)

	end)

end



local humanoid = script.Parent:WaitForChild("Humanoid")



listenForNewAnimations(humanoid)

IsPlaying

bool
Lecture uniquement
Non répliqué
Lecture parallèle

Une propriété de lecture qui renvoie vrai quand la AnimationTrack joue.

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 causerait sa redémarrer). Si un développeur souhaite obtenir toutes les jouant AnimationTracks sur un Humanoid ou AnimationController il devrait utiliser 1> Class.Humanoid:GetPlay

Échantillons de code

AnimationTrack IsPlaying
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

number
Lecture uniquement
Non répliqué
Lecture parallèle

Une propriété de lecture qui renvoie la longueur (en secondes) d'une AnimationTrack . Ce sera renvoyé 0 jusqu'à ce que l'animation soit entièrement chargée et donc ne peut pas être immédiatement disponible.

Lorsque la valeur AnimationTrack.Speed d'un AnimationTrack est égale à 1, l'animation prendra AnimationTrack.Length (en secondes) pour se terminer.

Échantillons de code

Playing Animation for a Specific Duration
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

bool
Lecture parallèle

Cette propriété détermine si l'animation se répétera après la fin. Si elle est modifiée pendant que vous jouez, l'animation prendra effet après la fin de l'animation.

La propriété Looped pour AnimationTrack par défaut se base sur la façon dont elle est définie dans l'éditeur d'animation. Cependant, cette propriété peut être modifiée, ce qui permet de contrôler sur la AnimationTrack pendant que le jeu s'exécute. Looped gère également correctement les animations jouées à l'envers (AnimationTrack.Speed négatif). Après

Cette propriété permet au développeur d'avoir une variante de boucle et non boucle de la même animations, sans avoir à télécharger deux versions sur Roblox.

Échantillons de code

Animation Looping
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()
Play AnimationTrack for a Number of Loops
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() -- it's important to disconnect connections when they are no longer needed

		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

Enum.AnimationPriority
Lecture parallèle

Cette propriété détermine la priorité d'un AnimationTrack. Selon ce que vous choisissez, le jeu de plusieurs animations à la fois regardera à cette propriété pour déterminer lequel des Keyframe et Poses devra être joué l'un sur l'autre.

La propriété priorité pour AnimationTrack par défaut se base sur la façon dont il a été défini et publié à partir de Studio's Animation Editor . Il utilise Enum.AnimationPriority qui a 7 niveaux de priorité :

  1. Action4 (priorité la plus élevée)
  2. Action3
  3. Action 2
  4. Action
  5. Mouvement
  6. Inactif
  7. Cœur (priorité la plus basse)

Définir les priorités d'animation, soit via l'éditeur, soit via cette propriété, permet de jouer plusieurs animations sans qu'elles se heurtent. Dans le cas où deux animations de lecture dirigent la cible pour déplacer le même membre dans différentes façons, le AnimationTrack avec la priorité la plus élevée afficher. 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 besoin de télécharger des versions supplémentaires sur Roblox.

Speed

number
Lecture uniquement
Non répliqué
Lecture parallèle

La vitesse d'une AnimationTrack est une propriété de lecture qui donne la vitesse de lecture actuelle de la AnimationTrack. Ce paramètre a une valeur par défaut de 1. Lorsque la vitesse est égale à 1, le temps de chargement d'une animation est équivalant à AnimationTrack.Length (en secondes).

Si la vitesse est ajustée, alors le temps de jeu d'une piste peut être calculé en divisant la longueur par la vitesse. La vitesse est une quantité infinie.

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

Animation Speed
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")
Playing Animation for a Specific Duration
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

number
Non répliqué
Lecture parallèle

Renvoie la position à temps en secondes dans lesquelles un AnimationTrack est en jouant son animationssource. Peut être réglé pour sauter la piste à un moment spécifique dans l'animations.

TimePosition peut être réglé pour aller à un point spécifique dans l'animations, mais le AnimationTrack doit jouer pour le faire. Il peut également être utilisé en combinaison avec AnimationTrack:AdjustSpeed() pour geler l'animation à un point souhaité (en réglant la vitesse sur 0).

Échantillons de code

Freeze Animation at Position
function freezeAnimationAtTime(animationTrack, timePosition)

	if not animationTrack.IsPlaying then

		-- Play the animation if it is not playing

		animationTrack:Play()

	end

	-- Set the speed to 0 to freeze the animation

	animationTrack:AdjustSpeed(0)

	-- Jump to the desired TimePosition

	animationTrack.TimePosition = timePosition

end



function freezeAnimationAtPercent(animationTrack, percentagePosition)

	if not animationTrack.IsPlaying then

		-- Play the animation if it is not playing

		animationTrack:Play()

	end

	-- Set the speed to 0 to freeze the animation

	animationTrack:AdjustSpeed(0)

	-- Jump to the desired TimePosition

	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

number
Lecture uniquement
Non répliqué
Lecture parallèle

Lorsque le poids est défini dans un AnimationTrack, il ne change pas instantanément mais se déplace du poids actuel au AnimationTrack.WeightTarget. Le temps qu'il faut pour faire cela est déterminé par le paramètre fadeTime lorsque l'animation est jouée, ou que 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 devraient pas être vérifiées pour l'égalité avec l'opérateur ==, car les deux de ces valeurs sont des flottants. Pour voir si WeightCurrent a atteint le poids souhaité, il est recommandé de voir si la distance entre ces deux valeurs est suffisamment petite (voir l'échantillon de code ci-dessous).

Le système de poids des animations est utilisé pour déterminer comment les AnimationTracks qui jouent à la même priorité sont mêlés ensemble. Le poids par défaut est un, et aucun mouvement ne

Échantillons de code

WeightCurrent and WeightTarget
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) -- arbitrary wait time to allow the character to fall into 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

end

WeightTarget

number
Lecture uniquement
Non répliqué
Lecture parallèle

AnimationTrack.WeightTarget est une propriété de lecture unique qui donne la valeur de poids actuelle de la AnimationTrack. Il a une valeur par défaut de 1 et est dé

WeightCurrent peut être vérifié contre AnimationTrack.WeightTarget pour voir si le poids souhaité a été atteint. Notez que ces valeurs ne devraient pas être vérifiées pour l'égalité avec l'opérateur ==, car les deux de ces valeurs sont des flottants. Pour voir si WeightCurrent a atteint le poids souhaité, il est recommandé de voir si la distance entre ces deux valeurs est suffisamment petite (voir l'échantillon de code ci-dessous).

Le système de poids des animations est utilisé pour déterminer comment les AnimationTracks qui jouent à la même priorité sont mêlés ensemble. Le poids par défaut est un, et aucun mouvement ne

Échantillons de code

WeightCurrent and WeightTarget
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) -- arbitrary wait time to allow the character to fall into 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

end
Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Méthodes

AdjustSpeed

void

Cette fonction change 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 la met en pause.

La vitesse initiale d'un AnimationTrack est définie comme un paramètre dans AnimationTrack:Play(). Cependant, la vitesse d'un circuit peut être modifiée pendant le jeu, en utilisant AdjustSpeed. Lorsque la vitesse est égale à 1, le temps de jeu correspondant est équivalant à AnimationTrack.Length (en secondes).

Lorsque l'ajustement est ajusté, le temps de jeu réel d'une piste peut être calculé en divisant la longueur par la vitesse. La vitesse est une quantité infinie.

La vitesse peut être utilisée pour lier la longueur 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

speed: number

La vitesse de lecture à laquelle l'animation est à changer.

Valeur par défaut : 1

Retours

void

Échantillons de code

Playing Animation for a Specific Duration
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)
Animation Speed
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

void

Change le poids d'une animations, avec le paramètre de fin d'année optionnel déterminant combien de temps il faut pour que AnimationTrack.WeightCurrent atteigne AnimationTrack.WeightTarget.

Lorsque le poids est défini dans un AnimationTrack, il ne change pas instantanément mais se déplace du poids actuel au AnimationTrack.WeightTarget. Le temps qu'il faut pour faire cela est déterminé par le paramètre fadeTime lorsque l'animation est jouée, ou que 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 devraient pas être vérifiées pour l'égalité avec l'opérateur ==, car les deux de ces valeurs sont des flottants. Pour voir si WeightCurrent a atteint le poids souhaité, il est recommandé de voir si la distance entre ces deux valeurs est suffisamment petite (voir l'échantillon de code ci-dessous).

Le système de poids de l'animation est utilisé pour déterminer comment les AnimationTracks qui jouent à la même priorité sont mêlés ensemble. Le poids par déf

Paramètres

weight: number

Le poids que l'animation est censé être modifié.

Valeur par défaut : 1
fadeTime: number

La durée du temps pendant laquelle l'animation fera entre le vieux poids et le nouveau poids pour.

Valeur par défaut : 0.100000001

Retours

void

Échantillons de code

AnimationTrack Change Weight
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

RBXScriptSignal

Cette fonction renvoie un event similaire à l'événement AnimationTrack.KeyframeReached, excepté qu'il ne se déclenche que lorsqu'un KeyframeMarker spécifié a été touché dans un 1> Class.Animation|animation1>. La différence permet un meilleur contrôle de quand 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.

Plus sur les clés

Keyframe les noms peuvent être définis dans le Éditeur d'animation Roblox lors de la création ou de l'édition d'une animations. Ils ne peuvent pas, cependant, être définis par un Script sur une ancienne animation avant de la jouer.

Keyframe les noms ne doivent pas être uniques. Par exemple, si un Animation a trois cadres clés nommés « ÉmetParticles », l'événement connecté par cette fonction lancera chaque fois qu'un de ces cadres clés est atteint.

Voir aussi :

Paramètres

name: string

Le nom du KeyFrameMarker le signal est en cours de création.


Retours

RBXScriptSignal

Le signal créé et tiré lorsque l'animation atteint le créé KeyFrameMarker .

Échantillons de code

Listening to Keyframe Markers
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

number

Renvoie la position dans le temps du premier Keyframe du nom donné dans un AnimationTrack. Si plusieurs Keyframes partagent le même nom, il renverra le plus ancien dans l'animations.

Cette fonction renverra une erreur si elle est utilisée avec un nom de clé non valide (un nom de clé invalide, par exemple) ou si la valeur sous-jacente Animation n'a pas encore été chargée. Pour résoudre cela, assurez-vous que seuls les noms de 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

keyframeName: string

Le nom associé avec le Keyframe à trouver.


Retours

number

Le temps, en secondes, le Keyframe se produit à une vitesse de lecture normale.

Échantillons de code

Jump To Keyframe
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

void

Lorsque AnimationTrack:Play() est appelé, l'animation de la piste commencera à jouer et le poids de l'animation augmentera de 0 à la valeur spécifiée (par défaut à 1) au moment de la fusion (la valeur par défaut est 0,1).

La vitesse à laquelle le AnimationTrack jouera dépend du paramètre de vitesse (par défaut, 1). Lorsque la vitesse est égale à 1, le nombre de secondes que le circuit prendra pour se terminer est également égale à la propriété de AnimationTrack.Length du circuit. Par exemple, une vitesse de 2 provoquera le double de vitesse de lecture.

Le poids et la vitesse de l'animation peuvent également être modifiés après le début du jeu en utilisant les méthodes AnimationTrack:AdjustWeight() et AnimationTrack:AdjustSpeed().

Si le développeur veut commencer l'animation à un moment spécifique en utilisant AnimationTrack.TimePosition, il est important que l'animation soit jouée avant que cela ne soit fait.

Paramètres

fadeTime: number

La durée de la durée de vie de l'animationsdoit être effacée.

Valeur par défaut : 0.100000001
weight: number

Le poids que l'animation doit être jouée à.

Valeur par défaut : 1
speed: number

La vitesse de lecture de l'animations.

Valeur par défaut : 1

Retours

void

Échantillons de code

Playing Animation for a Specific Duration
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)
Freeze Animation at Position
function freezeAnimationAtTime(animationTrack, timePosition)

	if not animationTrack.IsPlaying then

		-- Play the animation if it is not playing

		animationTrack:Play()

	end

	-- Set the speed to 0 to freeze the animation

	animationTrack:AdjustSpeed(0)

	-- Jump to the desired TimePosition

	animationTrack.TimePosition = timePosition

end



function freezeAnimationAtPercent(animationTrack, percentagePosition)

	if not animationTrack.IsPlaying then

		-- Play the animation if it is not playing

		animationTrack:Play()

	end

	-- Set the speed to 0 to freeze the animation

	animationTrack:AdjustSpeed(0)

	-- Jump to the desired TimePosition

	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)

Stop

void

Arrête le AnimationTrack . Une fois que la playback du AnimationTrack aura été appelé, l'arrêt du poids de l'animation se poursuivra et le poids de l'animation se déplacera vers zéro au cours d'une durée spécifiée par le paramètre d'expiration facultatif.

Par exemple, si Stop est appelé avec un temps de fondu de 2 secondes, il prendra deux secondes pour le poids de la AnimationTrack pour atteindre zéro et ses effets se termineront complètement. Veuillez noter que cela sera le cas indépendamment du poids initial de l'animations.

Il n'est pas recommandé d'utiliser un temps de fondu de 0 secondes pour essayer d'effacer cet effet et de terminer l'animation immédiatement comme actuellement, ce qui cause les AnimationTrack poses à geler.

Paramètres

fadeTime: number

Le temps, en secondes, pendant lequel le poids de l'animation doit être dilué.

Valeur par défaut : 0.100000001

Retours

void

Échantillons de code

AnimationTrack Stop
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)
Afficher tous les hérités de Instance
Afficher tous les hérités de Object

Évènements

DidLoop

Cet événement se déclenche toujours lorsqu'un AnimationTrack en boucle se termine, à la prochaine mise à jour.

Il peut également tirer à l'exacte fin d'une piste d'animation non bouclée mais ce comportement ne doit pas être attendu.


Échantillons de code

Play AnimationTrack for a Number of Loops
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() -- it's important to disconnect connections when they are no longer needed

		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

Feuille quand le AnimationTrack est complètement terminé de déplacer n'importe quoi dans le monde. L'animation a terminé de jouer, le "fade out" est terminé et le sujet est dans une posture neutre.

Vous pouvez utiliser ceci pour prendre une action lorsque le sujet de la piste d'animation est de retour dans une posture neutre qui n'est pas affectée par le AnimationTrack ou pour nettoyer le AnimationTrack. ou n'importe quelle connexion associée.


Échantillons de code

AnimationTrack Ended
local InsertService = game:GetService("InsertService")

local Players = game:GetService("Players")



-- Create an NPC model to animate.

local npcModel = Players:CreateHumanoidModelFromUserId(129687796)

npcModel.Name = "JoeNPC"

npcModel.Parent = workspace

npcModel:MoveTo(Vector3.new(0, 15, 4))

local humanoid = npcModel:WaitForChild("Humanoid")



-- Load an animation.

local animationModel = InsertService:LoadAsset(2510238627)

local animation = animationModel:FindFirstChildWhichIsA("Animation", true)

local animator = humanoid:WaitForChild("Animator")

local animationTrack = animator:LoadAnimation(animation)



-- Connect to Stopped event. This fires when animation stops of

-- it's own accord, or we explicitly call Stop.

animationTrack.Stopped:Connect(function()

  print("Animation stopped")

end)



-- Connect to Ended event. This fires when when animation is completely

-- finished affecting the world. In this case it will fire 3 seconds

-- after we call animationTrack:Stop because we pass in a 3

-- second fadeOut.

animationTrack.Ended:Connect(function()

  print("Animation ended")

  animationTrack:Destroy()

end)



-- Run, give it a bit to play, then stop.

print("Calling Play")

animationTrack:Play()

task.wait(10)

print("Calling Stop")

animationTrack:Stop(3)

KeyframeReached

Démarre 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 de s'exécuter du code à des points prédéfinis dans une animation (définie par Keyframe noms). Cela permet à la fonctionnalité par défaut des animations Roblox d'être étendue en ajoutant Sounds ou ParticleEffects à différents points dans une animation.

Keyframe les noms ne doivent pas être uniques. Par exemple, si une animation a trois cadres de valeur nommés «Particles», l'événement KeyframeReached se déclenchera chaque fois qu'un de ces cadres de valeur est 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. Ils ne peuvent cependant pas être définis par un Script sur une ancienne animation avant de la jouer.

Paramètres

keyframeName: string

Le nom du Keyframe atteint.


Stopped

Tire quand le AnimationTrack est terminé de jouer.

Cet événement a une certaine utilisation. Il peut être utilisé pour attendre que l'événement AnimationTrack ait arrêté avant de continuer (par exemple, si vous chaînez une série d'animations à jouer après l'autre). Il peut également être utilisé pour nettoyer n'importe quel Instances créé pendant la lecture de l'animation.


Échantillons de code

AnimationTrack Stopped
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)
Afficher tous les hérités de Instance
Afficher tous les hérités de Object