AnimationTrack

Visualizza obsoleti

*Questo contenuto è tradotto usando AI (Beta) e potrebbe contenere errori. Per visualizzare questa pagina in inglese, clicca qui.

Non costruibile

Controlla il riproduzione di un'animazione su un Animator . Questo oggetto non può essere creato, invece viene restituito dal metodo Animator:LoadAnimation().

Sommario

Proprietà

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    L'oggetto Animation che è stato utilizzato per creare questo AnimationTrack .

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    Una proprietà solo lettura che restituisce vero quando il AnimationTrack sta giocando.

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    Una proprietà solo lettura che restituisce la lunghezza (in secondi) di un AnimationTrack .Questo restituirà 0 fino a quando l'animazione non sarà completamente caricata e quindi potrebbe non essere immediatamente disponibile.

  • Lettura Parallela

    Imposta se l'animazione si ripeterà dopo aver finito. Se viene cambiata durante il gioco, l'animazione avrà effetto dopo che l'animazione finisce.

  • Imposta la priorità di un AnimationTrack .A seconda di ciò che è impostato, giocare a più animazioni contemporaneamente cercherà questa proprietà per capire quale Class.Keyframe``Class.Pose|Poses deve essere riprodotta sull'un l'altra.

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    La velocità di un AnimationTrack è una proprietà di lettura solo che dà la velocità di riproduzione attuale del AnimationTrack .Questo ha un valore predefinito di 1.Quando la velocità è uguale a 1, la quantità di tempo che un'animazione richiede per completarsi è uguale a AnimationTrack.Length (in secondi).

  • Non Replicato
    Lettura Parallela

    Restituisce la posizione nel tempo in secondi in cui un AnimationTrack è attraverso il riproduzione della sua animazionidi origine.Può essere impostato per far saltare la traccia a un momento specifico nell'animazioni.

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    Proprietà read-only che fornisce il peso attuale del AnimationTrack . Ha un valore predefinito di 1.

  • Sola Lettura
    Non Replicato
    Lettura Parallela

    Proprietà read-only che fornisce il peso attuale del AnimationTrack .

Metodi

Eventi

Proprietà

Animation

Sola Lettura
Non Replicato
Lettura Parallela

L'oggetto Animation che è stato utilizzato per creare questo AnimationTrack .Per creare un AnimationTrack , devi caricare un oggetto Animation su un Animator utilizzando il metodo Animator:LoadAnimation().

Campioni di codice

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.

Listen For New Animations

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

Sola Lettura
Non Replicato
Lettura Parallela

Una proprietà solo lettura che restituisce vero quando il AnimationTrack sta giocando.

Questa proprietà può essere utilizzata dagli sviluppatori per controllare se un'animazione è già in riproduzione prima di giocarci (in quanto ciò potrebbe causare il suo Ricomincia).Se uno sviluppatore desidera ottenere tutto il gioco AnimationTracks su un Animator o un Humanoid , dovrebbe usare Animator:GetPlayingAnimationTracks()

Campioni di codice

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.

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

Sola Lettura
Non Replicato
Lettura Parallela

Una proprietà solo lettura che restituisce la lunghezza (in secondi) di un AnimationTrack .Questo restituirà 0 fino a quando l'animazione non sarà completamente caricata e quindi potrebbe non essere immediatamente disponibile.

Quando il AnimationTrack.Speed di un AnimationTrack è uguale a 1, l'animazione richiederà AnimationTrack.Length (in secondi) per completarsi.

Campioni di codice

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).

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

Lettura Parallela

Questa proprietà imposta se l'animazione si ripeterà dopo aver finito.Se viene cambiato durante il gioco, il risultato avrà effetto dopo che l'animazione finisce.

La proprietà Looped per AnimationTrack predefinisce il modo in cui è stata impostata nell'editor di animazione.Tuttavia, questa proprietà può essere cambiata, consentendo il controllo su AnimationTrack mentre il gioco è in esecuzione.Looped gestisce anche correttamente le animazioni riprodotte all'indietro (negativo AnimationTrack.Speed ).Dopo che viene raggiunto il primo keyframe, verrà riavviato all'ultimo Fotogramma chiave.

Questa proprietà consente allo sviluppatore di avere una variante di loop e non di loop dell'animazionistessa, senza dover caricare due versioni su Roblox.

Campioni di codice

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.

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()

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.

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)
Lettura Parallela

Questa proprietà imposta la priorità di un AnimationTrack .A seconda di ciò che è impostato, giocare a più animazioni contemporaneamente cercherà questa proprietà per capire quale Class.Keyframe``Class.Pose|Poses deve essere riprodotta sull'un l'altra.

La proprietà Priorità per AnimationTrack predefinisce come è stata impostata e pubblicata dall'Editor di Animazione di Studio.Usa Enum.AnimationPriority che ha 7 livelli di priorità:

  1. Action4 (priorità più alta)
  2. Azione3
  3. Azione2
  4. Azione
  5. Movimento
  6. Inattivo
  7. Core (priorità più bassa)

Impostare correttamente le priorità di animazione, attraverso l'editor o attraverso questa Proprietà, consente di far giocare più animazioni senza che si scontrino.Dove due animazioni di gioco dirigono il bersaglio a muovere la stessa artiglia in modi diversi, la AnimationTrack con la priorità più alta Mostrare.Se entrambe le animazioni hanno la stessa priorità, verranno utilizzati i pesi delle tracce per combinare le animazioni.

Questa proprietà consente inoltre al developer di riprodurre la stessa animazione a diverse priorità, senza dover caricare versioni aggiuntive su Roblox.

Speed

Sola Lettura
Non Replicato
Lettura Parallela

La velocità di un AnimationTrack è una proprietà di lettura solo che dà la velocità di riproduzione attuale del AnimationTrack .Questo ha un valore predefinito di 1.Quando la velocità è uguale a 1, la quantità di tempo che un'animazione richiede per completarsi è uguale a AnimationTrack.Length (in secondi).

Se la velocità viene regolata, poi il tempo effettivo che ci vorrà per giocare una traccia può essere calcolato dividendo la lunghezza per la velocità.La velocità è una quantità senza unità.

La velocità può essere utilizzata per collegare la lunghezza di un'animazione a diversi eventi di gioco (ad esempio ricaricare un'abilità) senza dover caricare diverse varianti della stessa animazioni.

Questa proprietà è solo letta e puoi cambiarla usando AnimationTrack:AdjustSpeed() .

Campioni di codice

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.

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")

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).

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

Non Replicato
Lettura Parallela

Restituisce la posizione nel tempo in secondi in cui un AnimationTrack è attraverso il riproduzione della sua animazionidi origine.Può essere impostato per far saltare la traccia a un momento specifico nell'animazioni.

La posizione temporale può essere impostata per andare a un punto specifico nell'animazioni, ma il AnimationTrack deve essere in riproduzione per farlo.Può essere utilizzato anche in combinazione con AnimationTrack:AdjustSpeed() per congelare l'animazione a un punto desiderato (impostando la velocità a 0).

Campioni di codice

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.

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

Sola Lettura
Non Replicato
Lettura Parallela

Quando il peso viene impostato in un AnimationTrack non cambia istantaneamente ma si sposta da WeightCurrent a AnimationTrack.WeightTarget .Il tempo necessario per farlo è determinato dal parametro fadeTime dato quando l'animazione viene riprodotta o il peso viene regolato.

WeightCurrent può essere controllato contro AnimationTrack.WeightTarget per vedere se il peso desiderato è stato raggiunto.Si noti che questi valori non devono essere controllati per l'uguaglianza con l'operatore ==, poiché entrambi questi valori sono float.Per vedere se WeightCurrent ha raggiunto il peso target, si consiglia di vedere se la distanza tra quei valori è sufficientemente piccola (vedi esempio di codice qui sotto).

Il sistema di bilanciamento dell'animazione viene utilizzato per determinare come AnimationTracks giocare con la stessa priorità vengono mescolati insieme.Il peso predefinito è uno e nessun movimento sarà visibile su un AnimationTrack con un peso di zero.La posa che viene mostrata in qualsiasi momento è determinata dalla media ponderata di tutti i Poses e dal PesoAttuale di ciascuno AnimationTrack .Nella maggior parte dei casi, le animazioni di fusione non sono richieste e l'utilizzo di AnimationTrack.Priority è più adatto.

Campioni di codice

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.

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

Sola Lettura
Non Replicato
Lettura Parallela

AnimationTrack.WeightTarget è una proprietà read-only che fornisce il peso attuale del AnimationTrack .Ha un valore predefinito di 1 e viene impostato quando AnimationTrack:Play() , AnimationTrack:Stop() o AnimationTrack:AdjustWeight() viene chiamato.Quando il peso viene impostato in un AnimationTrack non cambia istantaneamente ma si sposta da WeightCurrent a AnimationTrack.WeightTarget.Il tempo necessario per farlo è determinato dal parametro fadeTime dato quando l'animazione viene riprodotta o il peso viene regolato.

WeightCurrent può essere controllato contro AnimationTrack.WeightTarget per vedere se il peso desiderato è stato raggiunto.Si noti che questi valori non devono essere controllati per l'uguaglianza con l'operatore ==, poiché entrambi questi valori sono float.Per vedere se WeightCurrent ha raggiunto il peso target, si consiglia di vedere se la distanza tra quei valori è sufficientemente piccola (vedi esempio di codice qui sotto).

Il sistema di bilanciamento dell'animazione viene utilizzato per determinare come AnimationTracks giocare con la stessa priorità vengono mescolati insieme.Il peso predefinito è uno e nessun movimento sarà visibile su un AnimationTrack con un peso di zero.La posa che viene mostrata in qualsiasi momento è determinata dalla media ponderata di tutti i Poses e dal PesoAttuale di ciascuno AnimationTrack .Nella maggior parte dei casi, le animazioni di fusione non sono richieste e l'utilizzo di AnimationTrack.Priority è più adatto.

Campioni di codice

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.

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

Metodi

AdjustSpeed

()

Questa funzione cambia il AnimationTrack.Speed di un'animazioni.Un valore positivo per la velocità riproduce l'animazione in avanti, uno negativo la riproduce all'indietro e 0 la interrompe.

La velocità iniziale di un AnimationTrack viene impostata come parametro in AnimationTrack:Play() .Tuttavia, la velocità di una traccia può essere cambiata durante la riproduzione, utilizzando AdjustSpeed.Quando la velocità è uguale a 1, la quantità di tempo che un'animazione richiede per completarsi è uguale a AnimationTrack.Length (in secondi).

Quando viene aggiustato, poi il tempo effettivo che ci vorrà per giocare una traccia può essere calcolato dividendo la lunghezza per la velocità. La velocità è una quantità senza unità.

La velocità può essere utilizzata per collegare la lunghezza di un'animazione a diversi eventi di gioco (ad esempio ricaricare un'abilità) senza dover caricare diverse varianti della stessa animazioni.

Parametri

speed: number

La velocità di riproduzione dell'animazione deve essere cambiata.

Valore predefinito: 1

Restituzioni

()

Campioni di codice

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).

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)

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.

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

()

Cambia il peso di un'animazioni, con il parametro fadeTime opzionale che determina quanto tempo ci vuole per AnimationTrack.WeightCurrent raggiungere AnimationTrack.WeightTarget .

Quando il peso viene impostato in un AnimationTrack non cambia istantaneamente ma si sposta da WeightCurrent a AnimationTrack.WeightTarget .Il tempo necessario per farlo è determinato dal parametro fadeTime dato quando l'animazione viene riprodotta o il peso viene regolato.

WeightCurrent può essere controllato contro AnimationTrack.WeightTarget per vedere se il peso desiderato è stato raggiunto.Si noti che questi valori non devono essere controllati per l'uguaglianza con l'operatore ==, poiché entrambi questi valori sono float.Per vedere se WeightCurrent ha raggiunto il peso target, si consiglia di vedere se la distanza tra quei valori è sufficientemente piccola (vedi esempio di codice qui sotto).

Il sistema di bilanciamento dell'animazione viene utilizzato per determinare come AnimationTracks giocare con la stessa priorità vengono mescolati insieme.Il peso predefinito è uno e nessun movimento sarà visibile su un AnimationTrack con un peso di zero.La posa che viene mostrata in qualsiasi momento è determinata dalla media ponderata di tutti i Poses e dal PesoAttuale di ciascuno AnimationTrack .Vedi qui sotto per un esempio di fusione di animazione in pratica.Nella maggior parte dei casi, le animazioni di fusione non sono richieste e l'utilizzo di AnimationTrack.Priority è più adatto.

Parametri

weight: number

Il peso che l'animazione deve essere cambiato.

Valore predefinito: 1
fadeTime: number

La durata del tempo in cui l'animazione scomparirà tra il vecchio peso e il nuovo peso per.

Valore predefinito: 0.100000001

Restituzioni

()

Campioni di codice

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).

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

Questa funzione restituisce un event simile all'evento AnimationTrack.KeyframeReached, ma si attiva solo quando un KeyframeMarker specificato viene colpito in un animation .La differenza consente un maggiore controllo su quando l'evento verrà Lanciare.

Per saperne di più sull'utilizzo di questa funzione, vedi Eventi di animazione nell'articolo Editor di animazione.

Vedi anche:

Parametri

name: string

Il nome del segnale KeyframeMarker viene creato per. Non confondersi con il nome del Keyframe .

Valore predefinito: ""

Restituzioni

Il segnale creato e sparato quando l'animazione raggiunge il creato KeyframeMarker . Non confondersi con il nome del Keyframe .

Campioni di codice

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.

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)

GetTargetInstance

Parametri

name: string
Valore predefinito: ""

Restituzioni

GetTargetNames


Restituzioni

GetTimeOfKeyframe

Restituisce la posizione temporale del primo Keyframe del nome dato in un AnimationTrack .Se più Keyframes condividono lo stesso nome, restituirà l'animazionipiù antica.

Questa funzione restituirà un errore se viene utilizzata con un nome di keyframe non valido (uno che non esiste ad esempio) o se il sottostante Animation non è ancora stato caricato.Per affrontare questo assicurati di utilizzare solo nomi di keyframe corretti e l'animazione sia stata caricata prima di chiamare questa funzione.

Per controllare se l'animazione è stata caricata, verifica che il AnimationTrack.Length è maggiore di zero.

Parametri

keyframeName: string

Il nome associato al Keyframe da trovare.

Valore predefinito: ""

Restituzioni

Il tempo, in secondi, il Keyframe si verifica alla velocità di riproduzione normale.

Campioni di codice

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.

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

()

Quando AnimationTrack:Play() viene chiamata l'animazione della traccia inizierà a giocare e il peso dell'animazione aumenterà da 0 a quello specificato (predefinito 1) durante il tempo di transizione specificato (predefinito 0.1).

La velocità a cui il AnimationTrack giocherà è determinata dal parametro di velocità (predefinito 1).Quando la velocità è uguale a 1 il numero di secondi che la traccia impiegherà per completarsi è uguale alla Proprietàdella traccia AnimationTrack.Length .Ad esempio, una velocità di 2 farà giocare alla traccia due volte più velocemente.

Il peso e la velocità dell'animazione possono anche essere modificati dopo che l'animazione ha iniziato a giocare utilizzando i metodi AnimationTrack:AdjustWeight() e AnimationTrack:AdjustSpeed().

Se lo sviluppatore vuole avviare l'animazione a un punto specifico utilizzando AnimationTrack.TimePosition, è importante che l'animazione venga riprodotta prima che ciò sia fatto.

Parametri

fadeTime: number

La durata del tempo in cui il peso dell'animazionidovrebbe essere sbiadito.

Valore predefinito: 0.100000001
weight: number

Il peso dell'animazione da riprodurre.

Valore predefinito: 1
speed: number

La velocità di riproduzione dell'animazioni.

Valore predefinito: 1

Restituzioni

()

Campioni di codice

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).

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)

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.

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)

SetTargetInstance

()

Parametri

name: string
Valore predefinito: ""
target: Instance
Valore predefinito: ""

Restituzioni

()

Stop

()

Ferma il AnimationTrack .Una volta chiamata, il peso dell'animazione si sposterà verso lo zero nel corso di un periodo di tempo specificato dal parametro opzionale fadeTime.Ad esempio, se Stop() viene chiamato con un fadeTime di 2 , ci vorranno due secondi per raggiungere lo zero del peso della traccia e i suoi effetti Terminarecompletamente.Si prega di notare che questo sarà il caso indipendentemente dal peso iniziale dell'animazioni.

Non è consigliato utilizzare un fadeTime di 0 in un tentativo di annullare questo effetto e terminare l'animazione immediatamente per Motor6Ds che hanno il loro Motor.MaxVelocity impostato a zero, poiché ciò causa il congelamento delle articolazioni in Posto.Se deve terminare immediatamente, assicurati che il Motor.MaxVelocity di Motor6Ds nel tuo rig sia abbastanza alto per garantire loro uno scatto adeguato.

Parametri

fadeTime: number

Il tempo, in secondi, per cui il peso dell'animazione deve essere dissipato.

Valore predefinito: 0.100000001

Restituzioni

()

Campioni di codice

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).

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)

Eventi

DidLoop

Questo evento si attiva ogni volta che un ciclo AnimationTrack completa un ciclo, nell'Aggiornarmentosuccessivo.

Attualmente può anche sparare alla fine esatta di una traccia di animazione non loopata ma questo comportamento non dovrebbe essere affidato.


Campioni di codice

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.

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

Si accende quando il AnimationTrack è completamente finito di spostare qualsiasi cosa nel Mondo.L'animazione ha finito di giocare, il "fade out" è finito e il soggetto è in una posa neutra.

Puoi usarlo per agire quando il soggetto della traccia di animazione è tornato in una posa neutra che non è influenzata dal AnimationTrack o per pulire il AnimationTrack .o qualsiasi connessione associata.


Campioni di codice

The function in this code sample plays an animationTrack and yields until it has stopped and ended, printing at each step along the way.

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

Si attiva ogni volta che il riproduzione di un AnimationTrack raggiunge un Keyframe che non ha il nome predefinito - "Keyframe".

Questo evento consente a un sviluppatore di eseguire il codice a punti predefiniti in un'animazione (impostati da Keyframe nomi).Questo consente alla funzionalità predefinita delle animazioni di Roblox di essere estesa aggiungendo Sounds o ParticleEffects a punti diversi in un'animazione.

Keyframe i nomi non devono essere unici.Ad esempio, se un'Animazione ha tre keyframe chiamati "Particelle" l'evento KeyframeReached verrà attivato ogni volta che viene raggiunto uno di questi keyframe.

Keyframe i nomi possono essere impostati nell'Editor di animazione Roblox quando si crea o modifica un'animazioni.Non possono tuttavia essere impostati da un Script su un'animazione esistente prima di giocarci.

Parametri

keyframeName: string

Il nome del Keyframe raggiunto.


Stopped

Si accende ogni volta che il AnimationTrack finisce di giocare.

Questo evento ha una serie di usi.Può essere utilizzato per aspettare fino a quando un AnimationTrack non si è fermato prima di continuare (ad esempio, se incatenare una serie di animazioni da riprodurre dopo l'una l'altra).Può essere utilizzato anche per pulire qualsiasi Instances creato durante il riproduzione dell'animazione.


Campioni di codice

The function in this code sample will play an animationTrack and yield until it has stopped, before printing.

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)