AnimationTrack

Mostrar obsoleto

*Este contenido se traduce usando la IA (Beta) y puede contener errores. Para ver esta página en inglés, haz clic en aquí.

No creable

Controla la reproducción de una animación en un AnimationController . Este objeto no se puede crear, sino que se devuelve por el método Animator:LoadAnimation() .

Resumen

Propiedades

Animation:Animation
Solo lectura
No replicado
Leer paralelo
El objeto Animation que se usó para crear este AnimationTrack .
IsPlaying:bool
Solo lectura
No replicado
Leer paralelo
Una propiedad de lectura que devuelve true cuando el AnimationTrack está reproduciendo.
Length:number
Solo lectura
No replicado
Leer paralelo
Una propiedad de lectura que solo devuelve la longitud (en segundos) de un AnimationTrack . Esto devolverá 0 hasta que la animación se haya cargado completamente y, por lo tanto, no esté disponible inmediatamente.
Looped:bool
Leer paralelo
Establece si la animación se repetirá después de terminar. Si se cambia mientras se juega, tendrá efecto después de que la animación termine.
Priority:Enum.AnimationPriority
Leer paralelo
Establece la prioridad de un Class.AnimationTrack . Dependiendo de lo que se establezca, jugar múltiples animaciones a la vez le parecerá a esta propiedad para encontrar qué Class.Keyframe Class.Pose|Poses debería jugarse uno sobre el otro.
Speed:number
Solo lectura
No replicado
Leer paralelo
La velocidad de un AnimationTrack es una propiedad de lectura que otorga la velocidad de reproducción actual de la AnimationTrack . Esta tiene un valor predeterminado de 1. Cuando la velocidad es igual a 1, la cantidad de tiempo que se necesita para completar la animación es igual a AnimationTrack.Length (en segundos).
TimePosition:number
No replicado
Leer paralelo
Restablece la posición en el tiempo en segundos que un AnimationTrack está a través de jugar su animacionesde fuente. Se puede configurar para hacer que el salto de la pista a un momento específico en la animaciones.
WeightCurrent:number
Solo lectura
No replicado
Leer paralelo
Propiedad de lectura que otorga el peso actual del AnimationTrack . Tiene un valor predeterminado de 1.
WeightTarget:number
Solo lectura
No replicado
Leer paralelo
Propiedad de lectura que otorga el peso actual del AnimationTrack .

Ver todos los heredados de Instance

Ver todos los heredados de Object

Métodos

AdjustSpeed(speed : number):void
Cambia el AnimationTrack.Speed de una animaciones. Un valor positivo para la velocidad juga la animación hacia delante, un valor negativo la hace retroceder y 0 la pausa.
AdjustWeight(weight : number,fadeTime : number):void
Cambia el peso de una animaciones, con el parámetro de tiempo de desaparición opcional determinando cuánto tiempo tarda en alcanzar Class.AnimationTrack.WeightCurrent .
GetMarkerReachedSignal(name : string):RBXScriptSignal
Regresa un event que se activa cuando se ha golpeado un KeyframeMarker especificado en un animation .
GetTimeOfKeyframe(keyframeName : string):number
Devuelve la posición de tiempo del primer Keyframe del nombre dado en un AnimationTrack .
Play(fadeTime : number,weight : number,speed : number):void
Reproduce el AnimationTrack. Una vez que se llama un AnimationTrack, jugará con el tiempo de desaparición, peso y velocidad especificados.
Stop(fadeTime : number):void
Detiene el AnimationTrack . Una vez que se llama la reproducción del AnimationTrack , se detendrá y el peso de la animación se moverá hacia cero durante un período de tiempo especificado por el parámetro de tiempo de desaparición opcional.

Ver todos los heredados de Instance

Ver todos los heredados de Object

Eventos

DidLoop():RBXScriptSignal
Activa cuando se activan los ciclos de AnimationTrack en la próxima actualización después del final de la animación previa.
Ended():RBXScriptSignal
Se activa cuando el AnimationTrack está completamente listo para mover cualquier cosa en el mundo. La animación ha terminado de jugar, el "fade out" está terminado y el sujeto está en una postura neutral.
KeyframeReached(keyframeName : string):RBXScriptSignal
Dispara cada vez que la reproducción de un AnimationTrack alcanza un Keyframe que no tiene el nombre predeterminado - "Keyframe".
Stopped():RBXScriptSignal
Se activa cuando el AnimationTrack termina de jugar. El AnimationTrack aún puede animar al sujeto mientras la animación "fade out" está activa. Para atrapar cuando el AnimationTrack esté completamente terminado de mover cualquier cosa en el mundo, use el evento AnimationTrack.Ended.

Ver todos los heredados de Instance

Ver todos los heredados de Object

Propiedades

Animation

Solo lectura

No replicado

Leer paralelo

El objeto Animation que se utilizó para crear este AnimationTrack . Para crear un AnimationTrack , debes cargar un objeto 1>Class.Animation1> en un 4>Class.AnimationController4> usando el método 7>Class.Animator:LoadAnimation()7>.

Muestras de código

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

Solo lectura

No replicado

Leer paralelo

Una propiedad de lectura que devuelve true cuando el AnimationTrack está reproduciendo.

Esta propiedad se puede usar por los desarrolladores para ver si una animación ya está en reproducción antes de reproducirla (como eso causaría que se reinicie). Si un desarrollador desea obtener toda la animación AnimationTracks en un Humanoid o AnimationController debería usar 1> Class.Humanoid:GetPlayingAnimationTracks()

Muestras de código

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

Solo lectura

No replicado

Leer paralelo

Una propiedad de lectura que solo devuelve la longitud (en segundos) de un AnimationTrack . Esto devolverá 0 hasta que la animación se haya cargado completamente y, por lo tanto, no esté disponible inmediatamente.

Cuando el AnimationTrack.Speed de un AnimationTrack es igual a 1, la animación tomará AnimationTrack.Length (en segundos) para completarse.

Muestras de código

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

Leer paralelo

Esta propiedad establece si la animación se repetirá después de terminar. Si se cambia mientras se juega el resultado tendrá efecto después de que termine la animación.

La propiedad Looped para AnimationTrack predetermina cómo se establece en el editor de animación. Sin embargo, esta propiedad se puede cambiar, lo que permite controlar el AnimationTrack mientras se ejecuta el juego. Looped también maneja correctamente las animaciones jugadas al revés (AnimationTrack.Speed negativo). Después de que se alcanza la primera fotograma clave, se reinici

Esta propiedad permite al desarrollador tener una variante de animacionesque se repite y no repite, sin necesidad de subir dos versiones a Roblox.

Muestras de código

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

Leer paralelo

Esta propiedad establece la prioridad de un AnimationTrack . Dependiendo de lo que se establezca, jugar múltiples animaciones a la vez le parecerá a esta propiedad para encontrar qué Class.Keyframe``Class.Pose|Poses debería jugarse uno sobre el otro.

La propiedad de prioridad para AnimationTrack predetermina cómo se establece y publica desde el Studio's Editor de Animación . Usa Enum.AnimationPriority que tiene 7 niveles de prioridad:

Acción 4 (prioridad más alta)
Acción3
Acción 2
Acción
Movimiento
Inactivo
Esencia (prioridad más baja)

Establecer prioridades de animación, ya sea a través del editor o a través de esta propiedad, permite que se reproduzcan múltiples animaciones sin que chochen. Cuando dos animaciones de reproducción apuntan a mover el mismo miembro en diferentes modos, la AnimationTrack con la mayor prioridad mostrará. Si ambas animaciones tienen la misma prioridad, las pesas de las pistas se usarán para combinar las animaciones.

Esta propiedad también permite al desarrollador reproducir la misma animación en diferentes prioridades, sin necesidad de subir versiones adicionales a Roblox.

Speed

number

Solo lectura

No replicado

Leer paralelo

La velocidad de un AnimationTrack es una propiedad de lectura que otorga la velocidad de reproducción actual de la AnimationTrack . Esta tiene un valor predeterminado de 1. Cuando la velocidad es igual a 1, la cantidad de tiempo que se necesita para completar la animación es igual a AnimationTrack.Length (en segundos).

Si se ajusta la velocidad, entonces el tiempo real que se necesita para reproducir una pista se puede calcular dividiendo la longitud por la velocidad. La velocidad es una cantidad no unitaria.

La velocidad se puede usar para enlazar la duración de una animación a diferentes eventos del juego (por ejemplo, recargar una habilidad) sin tener que subir diferentes variantes de la misma animaciones.

Esta propiedad es solo de lectura, y puede cambiarla usando AnimationTrack:AdjustSpeed() .

Muestras de código

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

No replicado

Leer paralelo

Restablece la posición en el tiempo en segundos que un AnimationTrack está a través de jugar su animacionesde fuente. Se puede configurar para hacer que el salto de la pista a un momento específico en la animaciones.

TimePosition se puede establecer para ir a un punto específico en la animaciones, pero el AnimationTrack debe estar jugando para hacerlo. También se puede utilizar en combinación con AnimationTrack:AdjustSpeed() para congelar la animación en un punto deseado (estableciendo la velocidad a 0).

Muestras de código

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

Solo lectura

No replicado

Leer paralelo

Cuando se establece el peso en un AnimationTrack , no cambia instantáneamente sino que se mueve desde WeightCurrent a AnimationTrack.WeightTarget . El tiempo que se necesita para hacer esto se determina por el parámetro fadeTime cuando se reproducen las animaciones, o el peso se ajusta.

WeightCurrent se puede verificar contra AnimationTrack.WeightTarget para ver si el peso deseado se ha alcanzado. Tenga en cuenta que estos valores no deben ser verificados para la igualdad con el operador ==, ya que ambos de estos valores son flotantes. Para ver si WeightCurrent ha alcanzado el peso deseado, se recomienda verificar si la distancia entre estos valores es lo suficientemente pequeña (ver el ejemplo de código a continuación).

El sistema de peso de animación se usa para determinar cómo se mezclan los jugadores con la misma prioridad. El peso predeterminado es uno, y no se verá ningún movimiento en un AnimationTracks

Muestras de código

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

Solo lectura

No replicado

Leer paralelo

AnimationTrack.WeightTarget es una propiedad de lectura que otorga el peso actual del AnimationTrack . Tiene un valor predeterminado de 1 y se est

El sistema de peso de animación se usa para determinar cómo se mezclan los jugadores con la misma prioridad. El peso predeterminado es uno, y no se verá ningún movimiento en un AnimationTracks

Muestras de código

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

Ver todos los heredados de Instance

Ver todos los heredados de Object

Métodos

AdjustSpeed

void

Esta función cambia el AnimationTrack.Speed de una animaciones. Un valor positivo para la velocidad juga la animación hacia delante, un valor negativo la juga hacia atrás y 0 la pausa.

La velocidad inicial de un AnimationTrack se establece como un parámetro en AnimationTrack:Play() . Sin embargo, la velocidad de un track se puede cambiar durante el reproducción, usando AdjustSpeed. Cuando la velocidad es igual a 1, la cantidad de tiempo que se necesita para completar es igual a AnimationTrack.Length (en segundos).

Cuando se ajusta, entonces el tiempo real que se necesita para reproducir una pista se puede calcular dividiendo la longitud por la velocidad. La velocidad es una cantidad no unitaria.

La velocidad se puede usar para enlazar la duración de una animación a diferentes eventos de juego (por ejemplo, recargar una habilidad) sin tener que subir diferentes variantes de la misma animaciones.

Parámetros

speed: number

La velocidad de reproducción a la que se cambia la animación.

Valor predeterminado: 1

Devuelve

void

Muestras de código

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

Cambia el peso de una animaciones, con el parámetro de tiempo de desaparición opcional determinando cuánto tiempo tarda en alcanzar Class.AnimationTrack.WeightCurrent .

El sistema de peso de animación se usa para determinar cómo se mezclan los jugadores en la misma prioridad. El peso predeterminado es uno, y no se verá ningún movimiento en un

Parámetros

weight: number

El peso a cambiar a la animación.

Valor predeterminado: 1

fadeTime: number

La duración del tiempo que la animación desaparecerá entre el peso viejo y el nuevo para.

Valor predeterminado: 0.100000001

Devuelve

void

Muestras de código

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

Esta función返回一个 event similar al evento AnimationTrack.KeyframeReached , excepto que solo se activa cuando se ha alcanzado un KeyframeMarker especificado en un 2>Class.Animation|animation . La diferencia permite un mayor control de cuándo se desencadenarel evento.

Para obtener más información sobre el uso de esta función, see Eventos de animación in the Editor de animación article.

Más acerca de las marcos de clave

Keyframe nombres se pueden establecer en el Roblox Editor de Animación al crear o editar una animaciones. Sin embargo, no se pueden establecer por un Class.Script en una animación existente antes de jugarla.

Keyframe nombres no necesitan ser únicos. Por ejemplo, si un Animation tiene tres marcos de clave llamados "EmitParticles", el evento conectado que se devuelve por esta función se activará cada vez que uno de estos marcos de clave se alcanza.

Véase también:

AnimationTrack, controla la reproducción de una animación en un Humanoid o un AnimationController
Keyframe , sostiene el Poses aplicado a las articulaciones en un Model en un momento dado en una animaciones
Keyframe:AddMarker()
Keyframe:RemoveMarker()
Keyframe:GetMarkers()

Parámetros

name: string

El nombre del KeyFrameMarker el cual se está creando el señal.

Devuelve

RBXScriptSignal

La señal se creó y se disparó cuando la animación alcanzó el creado KeyFrameMarker .

Muestras de código

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

Devuelve la posición de tiempo del primer Keyframe del nombre dado en un AnimationTrack . Si varios Keyframes comparten el mismo nombre, devolverá el más antiguo en la animaciones.

Esta función devolverá un error si se usa con un nombre de marco de clave inválido (uno que no existe por ejemplo) o si el marco de claves subyacente no se ha cargado. Para abordar esto, asegúrese de que solo se usen nombres de marco de clave correctos y que la animación se haya cargado antes de llamar a esta función.

Para comprobar si la animación se ha cargado, verifique que la AnimationTrack.Length es mayor que cero.

Parámetros

keyframeName: string

El nombre asociado con el Keyframe para encontrar.

Devuelve

number

El tiempo, en segundos, que ocurre la Keyframe se realiza a la velocidad de reproducción normal.

Muestras de código

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

Cuando AnimationTrack:Play() se llama, la animación de la pista comenzará a jugar y el peso de la animación aumentará de 0 a el peso especificado (por defecto es 1) sobre el tiempo de desaparición especificado (es predeterminado 0.1).

La velocidad a la que se reproducirá el AnimationTrack depende del parámetro de velocidad (se predetermina 1). Cuando la velocidad sea igual a 1, la cantidad de segundos que se necesitan para completar el rastro será igual a la propiedad de rastro de AnimationTrack.Length del rastro. Por ejemplo, una velocidad de 2 hará que el rastro se reproduzca el doble de rápido.

El peso y la velocidad de la animación también se pueden cambiar después de que la animación haya comenzado a jugar usando los métodos AnimationTrack:AdjustWeight() y AnimationTrack:AdjustSpeed().

Si el desarrollador quiere iniciar la animación en un punto específico usando AnimationTrack.TimePosition , es importante que la animación se ejecute antes de que esto se haga.

Parámetros

fadeTime: number

La duración de tiempo en la que el peso de la animacionesdebería desaparecer.

Valor predeterminado: 0.100000001

weight: number

El peso del anuncio es para ser reproducido en.

Valor predeterminado: 1

speed: number

La velocidad de reproducción de la animaciones.

Valor predeterminado: 1

Devuelve

void

Muestras de código

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

Detiene el AnimationTrack . Una vez que se llama la reproducción del AnimationTrack , se detendrá y el peso de la animación se moverá hacia cero durante un período de tiempo especificado por el parámetro de tiempo de desaparición opcional.

Por ejemplo, si se llama Stop con un tiempo de desaparición de 2 segundos tomará dos segundos para el peso de la animación AnimationTrack para alcanzar cero y sus efectos completamente finalizar. Por favor, tenga en cuenta que esto será el caso independientemente del peso inicial de la animación.

No se recomienda usar un tiempo de desaparición de 0 segundos para intentar sobresalir este efecto y terminar la animación inmediatamente como se presenta, esto causa que las poses de AnimationTrack congelen.

Parámetros

fadeTime: number

El tiempo, en segundos, para el que se desvanecerá el peso de la animación.

Valor predeterminado: 0.100000001

Devuelve

void

Muestras de código

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)

Ver todos los heredados de Instance

Ver todos los heredados de Object

Eventos

DidLoop

Este evento se activa cuando se completa un ciclo de AnimationTrack , en la próxima actualización.

Actualmente también puede disparar en el final exacto de una animación no repetitiva, pero este comportamiento no debe confiarse.

Muestras de código

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

Se activa cuando el AnimationTrack está completamente listo para mover cualquier cosa en el mundo. La animación ha terminado de jugar, el "fade out" está terminado y el sujeto está en una postura neutral.

Puedes usar esto para tomar acción cuando el sujeto de la pista de animación vuelve en una postura neutral que no está afectada por el AnimationTrack o para limpiar el AnimationTrack . o cualquier conexión asociada.

Muestras de código

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

Obsoleto

Este evento ha sido superado por la función GetMarkerReachedSignal . Para más detalles, consulte Eventos de animación en Editor de animación .

Dispara cada vez que se reproducen uno de los AnimationTrack que alcanza un Keyframe que no tiene el nombre predeterminado - "Keyframe".

Este evento permite a un desarrollador ejecutar código en puntos predeterminados en una animación (establecidos por Keyframe nombres). Esto permite que la funcionalidad predeterminada de las animaciones de Roblox se expanda al agregar Sounds o ParticleEffects en diferentes puntos en una animación.

Keyframe nombres no necesitan ser únicos. Por ejemplo, si una animación tiene tres marcos de animación llamados "Partículas", el evento de KeyframeReached se disparará cada vez que uno de estos marcos de animación se alcanza.

Keyframe nombres se pueden establecer en el Editor de Animación de Roblox al crear o editar una animaciones. Sin embargo, no se pueden establecer por un Script en una animación existente antes de jugarla.

Parámetros

keyframeName: string

El nombre del Keyframe alcanzado.

Stopped

Dispara cuando el AnimationTrack termina de jugar.

Este evento tiene varios usos. Se puede usar para esperar hasta que un <a href="/reference/engine/datatypes"> Class.AnimationTrack</a> haya terminado antes de continuar (por ejemplo, si se enlaza una serie de animaciones para jugar después de cada otra). También se puede usar para limpiar cualquier <a href="/reference/engine/datatypes"> Class.Instance|Instances </a> creado durante el reproducción de animaciones.

Muestras de código

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)

Ver todos los heredados de Instance

Ver todos los heredados de Object