AnimationTrack
*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.
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() .
Resumo
Propriedades
El objeto Animation que se usó para crear este AnimationTrack .
Una propiedad de lectura que devuelve true cuando el AnimationTrack está reproduciendo.
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.
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.
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.
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).
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.
Propiedad de lectura que otorga el peso actual del AnimationTrack . Tiene un valor predeterminado de 1.
Propiedad de lectura que otorga el peso actual del AnimationTrack .
Métodos
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.
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 .
Regresa un event que se activa cuando se ha golpeado un KeyframeMarker especificado en un animation .
Devuelve la posición de tiempo del primer Keyframe del nombre dado en un AnimationTrack .
Reproduce el AnimationTrack. Una vez que se llama un AnimationTrack, jugará con el tiempo de desaparición, peso y velocidad especificados.
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.
Eventos
Activa cuando se activan los ciclos de AnimationTrack en la próxima actualización después del final de la animación previa.
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.
Dispara cada vez que la reproducción de un AnimationTrack alcanza un Keyframe que no tiene el nombre predeterminado - "Keyframe".
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.
Propriedades
Animation
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>.
Amostras de código
The following code sample prints the name of an animation whenever an AnimationTrack plays on a Humanoid. This script can be placed in a model with a Humanoid child.
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
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()
Amostras de código
This code sample includes a simple function that will play an AnimationTrack if it is not playing, or otherwise adjust its speed and weight to match the new parameters given.
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
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.
Amostras de código
The following function will play an AnimationTrack for a specific duration. This is done by changing the speed of the animation to the length of the animation divided by the desired playback duration. This could be used in situations where a developer wants to play a standard animation for different duration (for example, recharging different abilities).
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
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.
Amostras de código
The animation in this example normally loops. After the player and the animation are loaded the animation is played in a non-looped fashion then in a looped fashion.
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()The function in this code sample will play an AnimationTrack on a loop, for a specific number of loops, before stopping the animation.
In some cases the developer may want to stop a looped animation after a certain number of loops have completed, rather than after a certain amount of time. This is where the DidLoop event can be used.
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
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
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() .
Amostras de código
In this example a player and an animation is loaded. The Length of an AnimationTrack determines how long the track would take to play if the speed is at 1. If the speed is adjusted, then the actual time it will take a track to play can be computed by dividing the length by the 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")The following function will play an AnimationTrack for a specific duration. This is done by changing the speed of the animation to the length of the animation divided by the desired playback duration. This could be used in situations where a developer wants to play a standard animation for different duration (for example, recharging different abilities).
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
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).
Amostras de código
The following code sample includes two functions that demonstrate how AdjustSpeed and TimePosition can be used to freeze an animation at a particular point.
The first function freezes an animation at a particular point in time (defined in seconds). The second freezes at it at a percentage (between 0 or 100) by multiplying the percentage by the track length.
As TimePosition can not be used when an AnimationTrack is not playing, the functions check to make sure the animation is playing before proceeding.
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
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
Amostras de código
This code sample loads two animations onto the local player's Humanoid and demonstrates how the fadeTime paramater in AnimationTrack.Play determines how long it takes for an AnimationTrack's WeightCurrent to reach it's WeightTarget.
As WeightCurrent and WeightTarget are floats the == operator cannot be used to compare, instead it is more appropriate to check that the difference between them is sufficiently small to assume the weight fade has completed.
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
endWeightTarget
AnimationTrack.WeightTarget es una propiedad de lectura que otorga el peso actual del AnimationTrack . Tiene un valor predeterminado de 1 y se est
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
Amostras de código
This code sample loads two animations onto the local player's Humanoid and demonstrates how the fadeTime paramater in AnimationTrack.Play determines how long it takes for an AnimationTrack's WeightCurrent to reach it's WeightTarget.
As WeightCurrent and WeightTarget are floats the == operator cannot be used to compare, instead it is more appropriate to check that the difference between them is sufficiently small to assume the weight fade has completed.
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
endMétodos
AdjustSpeed
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
La velocidad de reproducción a la que se cambia la animación.
Devolução
Amostras de código
The following function will play an AnimationTrack for a specific duration. This is done by changing the speed of the animation to the length of the animation divided by the desired playback duration. This could be used in situations where a developer wants to play a standard animation for different duration (for example, recharging different abilities).
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)In this example a player and an animation is loaded. The Length of an AnimationTrack determines how long the track would take to play if the speed is at 1. If the speed is adjusted, then the actual time it will take a track to play can be computed by dividing the length by the 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
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 .
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 en la misma prioridad. El peso predeterminado es uno, y no se verá ningún movimiento en un
Parâmetros
El peso a cambiar a la animación.
La duración del tiempo que la animación desaparecerá entre el peso viejo y el nuevo para.
Devolução
Amostras de código
This code sample includes a function that changes the weight of an AnimationTrack and yields until the weight has changed to the new target weight.
The purpose of this sample is to demonstrate how the fadeTime parameter of AnimationTrack.AdjustWeight works. In most cases, if a developer wishes to yield over the fadeTime it is recommended they use 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
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:
Parâmetros
El nombre del KeyFrameMarker el cual se está creando el señal.
Devolução
La señal se creó y se disparó cuando la animación alcanzó el creado KeyFrameMarker .
Amostras de código
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
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
Devolução
Amostras de código
This sample includes a function that will jump to the first keyframe of a specified name in an AnimationTrack.
As AnimationTrack.TimePosition cannot be set while the animation is not playing the function first checks to see if the animation is playing.
This sample will only work once an Animation has loaded.
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
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
La duración de tiempo en la que el peso de la animacionesdebería desaparecer.
El peso del anuncio es para ser reproducido en.
La velocidad de reproducción de la animaciones.
Devolução
Amostras de código
The following function will play an AnimationTrack for a specific duration. This is done by changing the speed of the animation to the length of the animation divided by the desired playback duration. This could be used in situations where a developer wants to play a standard animation for different duration (for example, recharging different abilities).
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)The following code sample includes two functions that demonstrate how AdjustSpeed and TimePosition can be used to freeze an animation at a particular point.
The first function freezes an animation at a particular point in time (defined in seconds). The second freezes at it at a percentage (between 0 or 100) by multiplying the percentage by the track length.
As TimePosition can not be used when an AnimationTrack is not playing, the functions check to make sure the animation is playing before proceeding.
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
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
El tiempo, en segundos, para el que se desvanecerá el peso de la animación.
Devolução
Amostras de código
This code sample includes a function that stops an AnimationTrack with a specific fadeTime, and yields until the fade is completed and the weight of the AnimationTrack is equal to zero.
The purpose of this sample is to demonstrate how the fadeTime parameter of AnimationTrack.Stop works. In most cases, if a developer wishes to yield over the fadeTime it is recommended they use 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)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.
Amostras de código
The function in this code sample will play an AnimationTrack on a loop, for a specific number of loops, before stopping the animation.
In some cases the developer may want to stop a looped animation after a certain number of loops have completed, rather than after a certain amount of time. This is where the DidLoop event can be used.
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.
Amostras de código
The function in this code sample plays an animationTrack and yields until it has stopped and ended, printing at each step along the way.
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
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
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.
Amostras de código
The function in this code sample will play an animationTrack and yield until it has stopped, before printing.
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)