AnimationTrack
*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.
Controla a reprodução de uma animação em um Animator . Este objeto não pode ser criado, em vez disso, é retornado pelo método Animator:LoadAnimation().
Resumo
Propriedades
O objeto Animation que foi usado para criar este AnimationTrack.
Uma propriedade apenas de leitura que retorna verdadeiro quando o AnimationTrack está tocando.
Uma propriedade apenas de leitura que retorna o comprimento (em segundos) de um AnimationTrack .Isso retornará 0 até que a animação tenha sido totalmente carregada e, portanto, pode não estar imediatamente disponível.
Define se a animação vai se repetir após terminar. Se for alterada enquanto se joga, a animação terminará depois que o resultado entrar em vigor.
Define a prioridade de um AnimationTrack .Dependendo do que está definido, jogar várias animações de uma só vez buscará essa propriedade para descobrir qual Class.Keyframe``Class.Pose|Poses deve ser reproduzida sobre a outra.
A velocidade de um AnimationTrack é uma propriedade apenas de leitura que dá a velocidade de reprodução atual do AnimationTrack .Isso tem um valor padrão de 1.Quando a velocidade é igual a 1, a quantidade de tempo que uma animação leva para concluir é igual a AnimationTrack.Length (em segundos).
Retorna a posição no tempo em segundos que um AnimationTrack está através de jogar sua animaçõesde origem.Pode ser definido para fazer o pulo da trilha para um momento específico na animações.
Propriedade apenas de leitura que dá o peso atual do AnimationTrack. Tem um valor padrão de 1.
Propriedade apenas de leitura que dá o peso atual do AnimationTrack.
Métodos
Muda o AnimationTrack.Speed de uma animações. Um valor positivo para velocidade joga a animação para a frente, um negativo a faz girar para trás e 0 a pausa.
Muda o peso de uma animações, com o parâmetro fadeTime opcional determinando quanto tempo leva para AnimationTrack.WeightCurrent alcançar AnimationTrack.WeightTarget.
Retorna um event que dispara quando um KeyframeMarker especificado foi atingido em um animation .
Retorna a posição do tempo do primeiro Keyframe do nome dado em um AnimationTrack .
Reproduz o AnimationTrack. Uma vez chamado, um AnimationTrack jogará com o tempo de desaparecimento, peso e velocidade especificados.
Para o AnimationTrack.
Eventos
Incêndios quando um AnimationTrack loops na próxima atualização após o fim do ciclo de animação anterior.
Incêndios quando o AnimationTrack está completamente feito de mover qualquer coisa no mundo.A animação terminou de tocar, o "desaparecimento" está terminado e o assunto está em uma posição neutra.
Incêndios sempre que a reprodução de um AnimationTrack alcança um Keyframe que não tem o nome padrão - "Keyframe".
Incêndios quando o AnimationTrack termina de tocar.A Trilha de Animação ainda pode animar o assunto enquanto a animação "desaparece".Para capturar quando a AnimaçãoTrack estiver completamente feita de mover qualquer coisa no mundo, use o evento AnimationTrack.Ended.
Propriedades
Animation
O objeto Animation que foi usado para criar este AnimationTrack.Para criar um AnimationTrack , você deve carregar um objeto Animation em um Animator usando o método Animator:LoadAnimation().
Amostras de código
O seguinte exemplo de código imprime o nome de uma animação sempre que um AnimationTrack joga em um Humanoid.Este script pode ser colocado em um modelo com uma criança Humanoid filha.
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
Uma propriedade apenas de leitura que retorna verdadeiro quando o AnimationTrack está tocando.
Essa propriedade pode ser usada por desenvolvedores para verificar se uma animação já está sendo reproduzida antes de reproduzi-la (pois isso faria com que ela reiniciar).Se um desenvolvedor deseja obter todo o jogo AnimationTracks em um Animator ou um Humanoid, eles devem usar Animator:GetPlayingAnimationTracks()
Amostras de código
Este exemplo de código inclui uma função simples que tocará uma Trilha de Animação se não estiver tocando, ou de outro modo ajustará sua velocidade e peso para combinar com os novos parâmetros dados.
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
Uma propriedade apenas de leitura que retorna o comprimento (em segundos) de um AnimationTrack .Isso retornará 0 até que a animação tenha sido totalmente carregada e, portanto, pode não estar imediatamente disponível.
Quando o AnimationTrack.Speed de um AnimationTrack é igual a 1, a animação levará AnimationTrack.Length (em segundos) para concluir.
Amostras de código
A seguinte função tocará uma AnimaçãoTrack por um período específico.Isso é feito alterando a velocidade da animação para a duração da animação dividida pela duração de reprodução desejada.Isso poderia ser usado em situações em que um desenvolvedor quer jogar uma animação padrão por diferentes períodos de tempo (por exemplo, recarregando diferentes habilidades).
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
Essa propriedade define se a animação vai se repetir após terminar.Se for alterado enquanto se joga, o resultado terá efeito após a animação terminar.
A propriedade Looped para AnimationTrack padrão é como foi definida no editor de animação.No entanto, esta propriedade pode ser alterada, permitindo o controle sobre o AnimationTrack enquanto o jogo está em execução.Looped também lida corretamente as animações tocadas em reverso (negativo AnimationTrack.Speed ).Depois que o primeiro keyframe for alcançado, ele será reiniciado no último keyframe.
Essa propriedade permite que o desenvolvedor tenha uma variante de loop e não loop da mesma animações, sem precisar carregar duas versões no Roblox.
Amostras de código
A animação neste exemplo normalmente se repete.Depois que o jogador e a animação forem carregados, a animação é reproduzida de forma não repetitiva e, em seguida, de forma repetitiva.
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()A função neste exemplo de código tocará uma Trilha de Animação em um loop, por um número específico de loops, antes de parar a animação.
Em alguns casos, o desenvolvedor pode querer interromper uma animação em loop depois que um determinado número de loops tenha sido concluído, ao invés de depois de um determinado período de tempo.É aqui que o evento DidLoop pode ser usado.
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() -- é importante desconectar conexões quando elas não forem mais necessárias
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
Essa propriedade define a prioridade de um AnimationTrack .Dependendo do que está definido, jogar várias animações de uma só vez buscará essa propriedade para descobrir qual Class.Keyframe``Class.Pose|Poses deve ser reproduzida sobre a outra.
A propriedade de prioridade para padrão é como foi definida e publicada no Editor de Animação do Studio .Ela usa Enum.AnimationPriority que tem 7 níveis de prioridade:
- Ação4 (maior prioridade)
- Ação3
- Ação2
- Ação
- Movimento
- Ocioso
- Núcleo (prioridade mais baixa)
Definir prioridades de animação adequadamente, seja através do editor ou através dessa propriedade, permite que várias animações sejam reproduzidas sem elas entrarem em conflito.Quando duas animações de reprodução direcionam o alvo para mover a mesma extremidade de maneiras diferentes, a AnimationTrack com a maior prioridade exibir / mostrar.Se ambas as animações tiverem a mesma prioridade, os pesos das faixas serão usados para combinar as animações.
Essa propriedade também permite que o desenvolvedor execute a mesma animação em diferentes prioridades, sem precisar carregar versões adicionais no Roblox.
Speed
A velocidade de um AnimationTrack é uma propriedade apenas de leitura que dá a velocidade de reprodução atual do AnimationTrack .Isso tem um valor padrão de 1.Quando a velocidade é igual a 1, a quantidade de tempo que uma animação leva para concluir é igual a AnimationTrack.Length (em segundos).
Se a velocidade for ajustada, então o tempo real que levará para uma pista tocar pode ser calculado dividindo a duração pela velocidade.Velocidade é uma quantidade sem unidade.
A velocidade pode ser usada para vincular o comprimento de uma animação a diferentes eventos de jogo (por exemplo, recarregar uma habilidade) sem ter que carregar diferentes variantes da mesma animações.
Essa propriedade é apenas de leitura e você pode alterá-la usando AnimationTrack:AdjustSpeed().
Amostras de código
Neste exemplo, um jogador e uma animação são carregados.O comprimento de uma Trilha de Animação determina quanto tempo a trilha levaria para tocar se a velocidade estiver em 1.Se a velocidade for ajustada, então o tempo real que levará para uma pista tocar pode ser calculado dividindo a duração pela velocidade.
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")A seguinte função tocará uma AnimaçãoTrack por um período específico.Isso é feito alterando a velocidade da animação para a duração da animação dividida pela duração de reprodução desejada.Isso poderia ser usado em situações em que um desenvolvedor quer jogar uma animação padrão por diferentes períodos de tempo (por exemplo, recarregando diferentes habilidades).
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
Retorna a posição no tempo em segundos que um AnimationTrack está através de jogar sua animaçõesde origem.Pode ser definido para fazer o pulo da trilha para um momento específico na animações.
A posição do tempo pode ser definida para ir a um ponto específico na animações, mas o AnimationTrack deve estar tocando para fazer isso.Também pode ser usado em combinação com AnimationTrack:AdjustSpeed() para congelar a animação em um ponto desejado (definindo a velocidade para 0).
Amostras de código
O seguinte exemplo de código inclui duas funções que demonstram como AdjustSpeed e TimePosition podem ser usados para congelar uma animação em um ponto específico.
A primeira função congela uma animação em um ponto de tempo específico (definido em segundos).O segundo congela nisso em uma porcentagem (entre 0 ou 100) multiplicando a porcentagem pela duração da faixa.
Como o TimePosition não pode ser usado quando uma AnimaçãoTrack não está tocando, as funções verificam para garantir que a animação esteja tocando antes de prosseguir.
function freezeAnimationAtTime(animationTrack, timePosition)
if not animationTrack.IsPlaying then
-- Reproduza a animação se ela não estiver sendo reproduzida
animationTrack:Play()
end
-- Defina a velocidade para 0 para congelar a animação
animationTrack:AdjustSpeed(0)
-- Pule para a posição de tempo desejada
animationTrack.TimePosition = timePosition
end
function freezeAnimationAtPercent(animationTrack, percentagePosition)
if not animationTrack.IsPlaying then
-- Reproduza a animação se ela não estiver sendo reproduzida
animationTrack:Play()
end
-- Defina a velocidade para 0 para congelar a animação
animationTrack:AdjustSpeed(0)
-- Pule para a posição de tempo desejada
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
Quando o peso é definido em um AnimationTrack não muda instantaneamente, mas move-se de PesoAtual para AnimationTrack.WeightTarget .O tempo que leva para fazer isso é determinado pelo parâmetro fadeTime dado quando a animação é reproduzida ou o peso é ajustado.
O WeightCurrent pode ser verificado contra AnimationTrack.WeightTarget para ver se o peso desejado foi atingido.Observe que esses valores não devem ser verificados por igualdade com o operador ==, pois ambos esses valores são flutuantes.Para ver se WeightCurrent atingiu o peso alvo, é recomendado verificar se a distância entre esses valores é suficientemente pequena (veja amostra de código abaixo).
O sistema de peso de animação é usado para determinar como AnimationTracks jogar com a mesma prioridade são misturados juntos.O peso padrão é um, e nenhum movimento será visível em um AnimationTrack com peso de zero.A posição que é mostrada em qualquer momento é determinada pela média ponderada de todos os Poses e o PesoAtual de cada AnimationTrack.Na maioria dos casos, não é necessário misturar animações e usar AnimationTrack.Priority é mais adequado.
Amostras de código
Este exemplo de código carrega duas animações no Humanoide do jogador local e demonstra como o parâmetro fadeTime na AnimaçãoTrack.Play determina o tempo que leva para que o WeightCurrent de uma AnimaçãoTrack alcance seu alvo de peso.
Como WeightCurrent e WeightTarget são flutuantes, o operador == não pode ser usado para comparar, em vez disso, é mais apropriado verificar se a diferença entre eles é suficientemente pequena para assumir que o desaparecimento do peso concluiu.
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) -- tempo de espera arbitrário para permitir que o personagem entre em vigor
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
AnimaçãoTrack.WeightTarget é uma propriedade de leitura somente que dá o peso atual do AnimationTrack.Ela tem um valor padrão de 1 e é definida quando AnimationTrack:Play() , AnimationTrack:Stop() ou AnimationTrack:AdjustWeight() é chamada.Quando o peso é definido em um AnimationTrack ele não muda instantaneamente, mas move-se de PesoAtual para AnimationTrack.WeightTarget.O tempo que leva para fazer isso é determinado pelo parâmetro fadeTime dado quando a animação é reproduzida ou o peso é ajustado.
O WeightCurrent pode ser verificado contra AnimationTrack.WeightTarget para ver se o peso desejado foi atingido.Observe que esses valores não devem ser verificados por igualdade com o operador ==, pois ambos esses valores são flutuantes.Para ver se WeightCurrent atingiu o peso alvo, é recomendado verificar se a distância entre esses valores é suficientemente pequena (veja amostra de código abaixo).
O sistema de peso de animação é usado para determinar como AnimationTracks jogar com a mesma prioridade são misturados juntos.O peso padrão é um, e nenhum movimento será visível em um AnimationTrack com peso de zero.A posição que é mostrada em qualquer momento é determinada pela média ponderada de todos os Poses e o PesoAtual de cada AnimationTrack.Na maioria dos casos, não é necessário misturar animações e usar AnimationTrack.Priority é mais adequado.
Amostras de código
Este exemplo de código carrega duas animações no Humanoide do jogador local e demonstra como o parâmetro fadeTime na AnimaçãoTrack.Play determina o tempo que leva para que o WeightCurrent de uma AnimaçãoTrack alcance seu alvo de peso.
Como WeightCurrent e WeightTarget são flutuantes, o operador == não pode ser usado para comparar, em vez disso, é mais apropriado verificar se a diferença entre eles é suficientemente pequena para assumir que o desaparecimento do peso concluiu.
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) -- tempo de espera arbitrário para permitir que o personagem entre em vigor
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
Essa função altera o AnimationTrack.Speed de uma animações.Um valor positivo para velocidade joga a animação para frente, um negativo a faz avançar e 0 a pausa.
A velocidade inicial de uma Trilha de Animação é definida como um parâmetro em AnimationTrack:Play() .No entanto, a velocidade de uma faixa pode ser alterada durante a reprodução, usando AdjustSpeed.Quando a velocidade é igual a 1, a quantidade de tempo que uma animação leva para completar é igual a AnimationTrack.Length (em segundos).
Quando é ajustado, então o tempo real que levará para uma pista tocar pode ser calculado dividindo a duração pela velocidade. A velocidade é uma quantidade sem unidade.
A velocidade pode ser usada para vincular a duração de uma animação a diferentes eventos de jogabilidade (por exemplo, recarregar uma habilidade) sem ter que carregar diferentes variantes da mesma animações.
Parâmetros
A velocidade de reprodução da animação que deve ser alterada.
Devolução
Amostras de código
A seguinte função tocará uma AnimaçãoTrack por um período específico.Isso é feito alterando a velocidade da animação para a duração da animação dividida pela duração de reprodução desejada.Isso poderia ser usado em situações em que um desenvolvedor quer jogar uma animação padrão por diferentes períodos de tempo (por exemplo, recarregando diferentes habilidades).
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)Neste exemplo, um jogador e uma animação são carregados.O comprimento de uma Trilha de Animação determina quanto tempo a trilha levaria para tocar se a velocidade estiver em 1.Se a velocidade for ajustada, então o tempo real que levará para uma pista tocar pode ser calculado dividindo a duração pela velocidade.
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
Muda o peso de uma animações, com o parâmetro fadeTime opcional determinando quanto tempo leva para AnimationTrack.WeightCurrent alcançar AnimationTrack.WeightTarget.
Quando o peso é definido em um AnimationTrack não muda instantaneamente, mas move-se de PesoAtual para AnimationTrack.WeightTarget .O tempo que leva para fazer isso é determinado pelo parâmetro fadeTime dado quando a animação é reproduzida ou o peso é ajustado.
O WeightCurrent pode ser verificado contra AnimationTrack.WeightTarget para ver se o peso desejado foi atingido.Observe que esses valores não devem ser verificados por igualdade com o operador ==, pois ambos esses valores são flutuantes.Para ver se WeightCurrent atingiu o peso alvo, é recomendado verificar se a distância entre esses valores é suficientemente pequena (veja amostra de código abaixo).
O sistema de peso de animação é usado para determinar como AnimationTracks jogar com a mesma prioridade são misturados juntos.O peso padrão é um, e nenhum movimento será visível em um AnimationTrack com peso de zero.A posição que é mostrada em qualquer momento é determinada pela média ponderada de todos os Poses e o PesoAtual de cada AnimationTrack.Veja abaixo um exemplo de fusão de animação na prática.Na maioria dos casos, não é necessário misturar animações e usar AnimationTrack.Priority é mais adequado.
Parâmetros
O peso que a animação deve ser alterado para.
A duração do tempo que a animação desaparecerá entre o peso antigo e o novo peso para.
Devolução
Amostras de código
Este exemplo de código inclui uma função que altera o peso de uma AnimaçãoTrack e rende até que o peso tenha mudado para o novo peso alvo.
O objetivo deste exemplo é demonstrar como o parâmetro fadeTime da AnimationTrack.AdjustWeight funciona.Na maioria dos casos, se um desenvolvedor deseja superar o tempo de desaparecimento, é recomendado que 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
Essa função retorna um event semelhante ao evento AnimationTrack.KeyframeReached, exceto que só é acionada quando um KeyframeMarker especificado for atingido em um animation .A diferença permite um maior controle de quando o evento será Iniciar / executar.
Para aprender mais sobre o uso dessa função, veja Eventos de Animação no artigo Editor de Animação.
Veja também:
Parâmetros
O nome do sinal que está sendo criado para. Não confundir com o nome do .
Devolução
O sinal criado e disparado quando a animação chegar ao criado KeyframeMarker. Não confundir com o nome do Keyframe.
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
Retorna a posição do tempo do primeiro Keyframe do nome dado em um AnimationTrack .Se vários Keyframes compartilharem o mesmo nome, ele retornará o mais antigo na animações.
Essa função retornará um erro se for usada com um nome de quadro de chave inválido (um que não existe, por exemplo) ou se o subjacente Animation ainda não foi carregado.Para abordar isso, certifique-se de que apenas nomes de quadro de chave corretos são usados e a animação foi carregada antes de chamar essa função.
Para verificar se a animação foi carregada, verifique se o AnimationTrack.Length é maior que zero.
Parâmetros
Devolução
Amostras de código
Esta amostra inclui uma função que saltará para o primeiro quadro de chave de um nome especificado em um AnimationTrack.
Como o AnimaçãoTrack.TimePosition não pode ser definido enquanto a animação não estiver tocando a função, primeiro verifica se a animação está tocando.
Esta amostra só funcionará quando uma Animação for carregada.
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() é chamada, a animação da faixa começará a tocar e o peso da animação aumentará de 0 para o peso especificado (padrão é 1) sobre o tempo de desaparecimento especificado (padrão é 0.1).
A velocidade em que o AnimationTrack tocará é determinada pelo parâmetro de velocidade (padrão é 1).Quando a velocidade é igual a 1, o número de segundos que a faixa levará para completar é igual à propriedade da faixa AnimationTrack.Length .Por exemplo, uma velocidade de 2 fará com que a pista seja reproduzida duas vezes mais rápido.
O peso e a velocidade da animação também podem ser alterados após a animação começar a tocar usando os métodos AnimationTrack:AdjustWeight() e AnimationTrack:AdjustSpeed().
Se o desenvolvedor quiser iniciar a animação em um ponto específico usando AnimationTrack.TimePosition, é importante que a animação seja reproduzida antes que isso seja feito.
Parâmetros
A duração do tempo que o peso da animaçõesdeve desaparecer por.
O peso que a animação deve ser tocada.
A velocidade de reprodução da animações.
Devolução
Amostras de código
A seguinte função tocará uma AnimaçãoTrack por um período específico.Isso é feito alterando a velocidade da animação para a duração da animação dividida pela duração de reprodução desejada.Isso poderia ser usado em situações em que um desenvolvedor quer jogar uma animação padrão por diferentes períodos de tempo (por exemplo, recarregando diferentes habilidades).
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)O seguinte exemplo de código inclui duas funções que demonstram como AdjustSpeed e TimePosition podem ser usados para congelar uma animação em um ponto específico.
A primeira função congela uma animação em um ponto de tempo específico (definido em segundos).O segundo congela nisso em uma porcentagem (entre 0 ou 100) multiplicando a porcentagem pela duração da faixa.
Como o TimePosition não pode ser usado quando uma AnimaçãoTrack não está tocando, as funções verificam para garantir que a animação esteja tocando antes de prosseguir.
function freezeAnimationAtTime(animationTrack, timePosition)
if not animationTrack.IsPlaying then
-- Reproduza a animação se ela não estiver sendo reproduzida
animationTrack:Play()
end
-- Defina a velocidade para 0 para congelar a animação
animationTrack:AdjustSpeed(0)
-- Pule para a posição de tempo desejada
animationTrack.TimePosition = timePosition
end
function freezeAnimationAtPercent(animationTrack, percentagePosition)
if not animationTrack.IsPlaying then
-- Reproduza a animação se ela não estiver sendo reproduzida
animationTrack:Play()
end
-- Defina a velocidade para 0 para congelar a animação
animationTrack:AdjustSpeed(0)
-- Pule para a posição de tempo desejada
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
Parâmetros
Devolução
Stop
Para o AnimationTrack.Uma vez chamada, o peso da animação se moverá para zero ao longo de um período de tempo especificado pelo parâmetro opcional fadeTime.Por exemplo, se Stop() for chamado com um fadeTime de 2 , levará dois segundos para o peso da trilha atingir zero e seus efeitos terminar/parar/saircompletamente.Observe que esse será o caso, independentemente do peso inicial da animações.
Não é recomendado usar um fadeTime de 0 em uma tentativa de anular esse efeito e terminar a animação imediatamente para Motor6Ds que têm seu Motor.MaxVelocity definido para zero, pois isso faz com que as articulações congelem no local.Se deve terminar imediatamente, garanta que o Motor.MaxVelocity de Motor6Ds em seu rig seja alto o suficiente para que eles se encaixem corretamente.
Parâmetros
O tempo, em segundos, para o qual o peso da animação deve ser desaparecido.
Devolução
Amostras de código
Este exemplo de código inclui uma função que interrompe uma AnimaçãoTrack com um tempo de desaparecimento específico e rende até que a transição seja concluída e o peso da AnimaçãoTrack seja igual a zero.
O objetivo deste exemplo é demonstrar como o parâmetro fadeTime de AnimationTrack.Stop funciona.Na maioria dos casos, se um desenvolvedor deseja superar o tempo de desaparecimento, é recomendado que 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 dispara sempre que um ciclo AnimationTrack completa um ciclo, na próxima atualização.
Atualmente, também pode atirar no final exato de uma faixa de animação não loopada, mas esse comportamento não deve ser confiável.
Amostras de código
A função neste exemplo de código tocará uma Trilha de Animação em um loop, por um número específico de loops, antes de parar a animação.
Em alguns casos, o desenvolvedor pode querer interromper uma animação em loop depois que um determinado número de loops tenha sido concluído, ao invés de depois de um determinado período de tempo.É aqui que o evento DidLoop pode ser usado.
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() -- é importante desconectar conexões quando elas não forem mais necessárias
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
Incêndios quando o AnimationTrack está completamente feito de mover qualquer coisa no mundo.A animação terminou de tocar, o "desaparecimento" está terminado e o assunto está em uma posição neutra.
Você pode usar isso para tomar medidas quando o assunto da trilha de animação está de volta em uma posição neutra que não é afetada pelo AnimationTrack ou para limpar o AnimationTrack.ou quaisquer conexões associadas.
Amostras de código
A função neste exemplo de código joga uma animaçãoTrack e rende até que tenha parado e terminado, imprimindo a cada passo ao longo do caminho.
local InsertService = game:GetService("InsertService")
local Players = game:GetService("Players")
-- Crie um modelo de NPC para animar.
local npcModel = Players:CreateHumanoidModelFromUserId(129687796)
npcModel.Name = "JoeNPC"
npcModel.Parent = workspace
npcModel:MoveTo(Vector3.new(0, 15, 4))
local humanoid = npcModel:WaitForChild("Humanoid")
-- Carregue uma animação.
local animationModel = InsertService:LoadAsset(2510238627)
local animation = animationModel:FindFirstChildWhichIsA("Animation", true)
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
-- Conecte-se ao evento Parado. Isso dispara quando a animação para de
-- de acordo próprio, ou chamamos explicitamente Stop.
animationTrack.Stopped:Connect(function()
print("Animation stopped")
end)
-- Conectar ao evento Terminado. Isso dispara quando a animação estiver completa
-- terminou de afetar o mundo. Neste caso, ele disparará por 3 segundos
-- depois de chamar a animaçãoTrack:Stop porque passamos em um 3
-- segundo fadeOut.
animationTrack.Ended:Connect(function()
print("Animation ended")
animationTrack:Destroy()
end)
-- Corra, dê um pouco para jogar, então pare.
print("Calling Play")
animationTrack:Play()
task.wait(10)
print("Calling Stop")
animationTrack:Stop(3)KeyframeReached
Incêndios sempre que a reprodução de um AnimationTrack alcança um Keyframe que não tem o nome padrão - "Keyframe".
Este evento permite que um desenvolvedor execute código em pontos predefinidos em uma animação (definidos por Keyframe nomes).Isso permite que a funcionalidade padrão das animações do Roblox seja expandida adicionando Sounds ou ParticleEffects em diferentes pontos de uma animação.
Keyframe nomes não precisam ser únicos.Por exemplo, se uma Animação tiver três quadros-chave chamados "Partículas", o evento KeyframeReached será disparado sempre que um desses quadros-chave for alcançado.
Keyframe nomes podem ser definidos no Editor de Animação Roblox ao criar ou editar uma animações.No entanto, eles não podem ser definidos por um Script em uma animação existente antes de tocá-la.
Parâmetros
Stopped
Incêndios sempre que o AnimationTrack termina de tocar.
Este evento tem uma série de usos.Pode ser usado para esperar até que um AnimationTrack tenha parado antes de continuar (por exemplo, se encadear uma série de animações para tocar após umas das outras).Também pode ser usado para limpar qualquer Instances criado durante a reprodução da animação.
Amostras de código
A função neste exemplo de código reproduzirá uma animaçãoTrack e renderizará até que tenha parado, antes de imprimir.
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)