AnimationTrack
*Ta zawartość została przetłumaczona przy użyciu narzędzi AI (w wersji beta) i może zawierać błędy. Aby wyświetlić tę stronę w języku angielskim, kliknij tutaj.
Kontroluje odtwarzanie animacji na Animator . Ten obiekt nie może zostać utworzony, zamiast tego zostanie zwrócony przez metodę Animator:LoadAnimation().
Podsumowanie
Właściwości
Przedmiot Animation, który został użyty do stworzenia tego AnimationTrack.
Właściwość tylko odczytowa, która zwraca prawdę, gdy AnimationTrack gra.
Właściwość tylko odczytowa, która zwraca długość (w sekundach) AnimationTrack .Wróci to 0, dopóki animacja nie zostanie w pełni załadowana i może nie być od razu dostępna.
Ustawia, czy animacja powtórzy się po zakończeniu. Jeśli zostanie zmieniona podczas grania, efekt zostanie włączony po zakończeniu animacji.
Ustawia priorytet AnimationTrack .W zależności od tego, co jest ustawione, odtwarzanie wielu animacji naraz będzie szukać tej właściwości, aby określić, które Class.Keyframe``Class.Pose|Poses powinny być odtwarzane jeden nad drugim.
Prędkość AnimationTrack jest właściwością tylko do odczytu, która daje obecną prędkość odtwarzania AnimationTrack .Ma domyślną wartość 1.Gdy prędkość jest równa 1, ilość czasu potrzebnego na ukończenie animacji wynosi AnimationTrack.Length (w sekundach).
Zwraca pozycję w czasie w sekundach, w których AnimationTrack gra w swoją animacjaźródła.Można ustawić, aby skok ścieżki do określonej chwili w animacja.
Właściwość tylko do odczytu, która daje obecną wagę AnimationTrack. Ma domyślną wartość 1.
Właściwość tylko do odczytu, która daje obecną wagę AnimationTrack .
Metody
Zmienia AnimationTrack.Speed animacja. Pozytywna wartość prędkości odtwarza animację do przodu, negatywna odtwarza ją do tyłu, a 0 wstrzymuje ją.
Zmienia wagę animacja, z opcjonalnym parametrem czasu trwania określającym, jak długo zajmie AnimationTrack.WeightCurrent dotarcie do AnimationTrack.WeightTarget.
Wyświetla event, który wystrzeliwuje, gdy określony KeyframeMarker zostanie uderzony w animation .
Zwraca pozycję czasu pierwszego Keyframe z daną nazwą w AnimationTrack .
Odtwarza AnimationTrack. Po wezwaniu AnimationTrack zagra z określonym czasem trwania, wagą i prędkością.
Zatrzymuje AnimationTrack .
Zdarzenia
Wypala się, gdy cykl AnimationTrack powtarza się w następnej aktualizacji po zakończeniu poprzedniego cyklu animacji.
Wypala się, gdy AnimationTrack zostanie całkowicie zakończone przenoszenie czegokolwiek w świecie.Animacja skończyła się odtwarzać, "nan" został zakończony, a temat jest w neutralnej pozie.
Wybucha za każdym razem, gdy odtwarzanie AnimationTrack osiąga Keyframe, które nie ma domyślnej nazwy - "Keyframe".
Wypala się, gdy AnimationTrack kończy odtwarzanie.Animacja ścieżki może nadal animować temat, podczas gdy animacja "nan" znika.Aby złapać, gdy ścieżka animacji skończy całkowicie przemieszczać coś w świecie, użyj wydarzenia AnimationTrack.Ended.
Właściwości
Animation
Przedmiot Animation, który został użyty do stworzenia tego AnimationTrack.Aby utworzyć AnimationTrack, musisz załadować obiekt Animation na Animator za pomocą metody Animator:LoadAnimation().
Przykłady kodu
Poniższy przykład kodu drukuje nazwę animacji za każdym razem, gdy AnimationTrack odtwarza się na Humanoid.Ten skrypt można umieścić w modelu z dzieckiem Humanoid .
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
Właściwość tylko odczytowa, która zwraca prawdę, gdy AnimationTrack gra.
Właściwość ta może być używana przez programistów do sprawdzenia, czy animacja jest już odtwarzana, zanim ją odtworzono (ponieważ spowodowałoby to jej ponowne uruchomienie).Jeśli programista chce uzyskać wszystkie odtwarzanie AnimationTracks na Animator lub Humanoid , powinien używać Animator:GetPlayingAnimationTracks()
Przykłady kodu
Ten przykład kodu zawiera prostą funkcję, która odtworzy animację ścieżki, jeśli nie odtwarza, lub w inny sposób dostosuje prędkość i wagę do podanych nowych parametrów.
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
Właściwość tylko odczytowa, która zwraca długość (w sekundach) AnimationTrack .Wróci to 0, dopóki animacja nie zostanie w pełni załadowana i może nie być od razu dostępna.
Kiedy AnimationTrack.Speed z AnimationTrack jest równy 1, animacja zajmie AnimationTrack.Length (w sekundach) na ukończenie.
Przykłady kodu
Następująca funkcja zagra animację dla określonego czasu trwania.Robi się to poprzez zmianę prędkości animacji na długość animacji podzieloną przez żądaną długość odtwarzania.Można go używać w sytuacjach, w których programista chce odtworzyć standardową animację przez różny czas (na przykład ponowne ładowanie różnych zdolności).
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
Właściwość ta określa, czy animacja powtórzy się po zakończeniu.Jeśli zostanie zmieniony podczas gry, efekt zacznie obowiązywać po zakończeniu animacji.
Właściwość Looped dla AnimationTrack domyślnie ustawia sposób ustawienia w edytorze animacji.Jednak ta właściwość może zostać zmieniona, umożliwiając kontrolę nad AnimationTrack podczas gdy gra się uruchamia.Looped również prawidłowo obsługuje animacje odtwarzane w odwrotnej kolejności (negatywna AnimationTrack.Speed ).Po osiągnięciu pierwszego kluczowego kadru zostanie ponownie uruchomiony na ostatnim kluczowym kadrze.
Właściwość ta pozwala programiście mieć wariant pętlowy i niepętlowy tej samej animacja, bez konieczności przesyłania dwóch wersji do Roblox.
Przykłady kodu
Animacja w tym przykładzie normalnie się powtarza.Po załadowaniu gracza i animacji animacja jest odtwarzana w sposób niezapętlony, a następnie w sposób zapętlony.
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()Funkcja w tym przykładzie kodu zagra animację na pętlu, dla określonej liczby pętli, zanim zatrzyma animację.
W niektórych przypadkach programista może chcieć zatrzymać powtarzającą się animację po zakończeniu pewnej liczby pętli, a nie po pewnym czasie.To jest miejsce, w którym można użyć wydarzenia DidLoop.
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() -- ważne jest odłączenie połączeń, gdy nie są już potrzebne
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
Właściwość ta ustawia priorytet AnimationTrack .W zależności od tego, co jest ustawione, odtwarzanie wielu animacji naraz będzie szukać tej właściwości, aby określić, które Class.Keyframe``Class.Pose|Poses powinny być odtwarzane jeden nad drugim.
Właściwość priorytetowa dla domyślnie ustawiona jest tak, jak została ustawiona i opublikowana z edytora animacji Studio .Używa Enum.AnimationPriority, który ma 7 poziomów priorytetowych:
- Akcja4 (najwyższy priorytet)
- Akcja3
- Akcja2
- Akcja
- Przesuwanie
- Nieaktywny
- Podstawowe (najniższy priorytet)
Prawidłowo ustawione priorytety animacji, za pomocą edytora lub za pomocą tej właściwości, pozwalają na odtwarzanie wielu animacji bez konfliktów.Gdzie dwie animacje odtwarzania kierują celem do przemieszczenia tej samej kończyny w różny sposób, pokaże się AnimationTrack z najwyższym priorytetem.Jeśli obie animacje mają ten sam priorytet, ciężary ścieżek zostaną wykorzystane do połączenia animacji.
Właściwość ta pozwala również programiście odtwarzać tę samą animację przy różnych priorytetach, bez konieczności przesyłania dodatkowych wersji do Roblox.
Speed
Prędkość AnimationTrack jest właściwością tylko do odczytu, która daje obecną prędkość odtwarzania AnimationTrack .Ma domyślną wartość 1.Gdy prędkość jest równa 1, ilość czasu potrzebnego na ukończenie animacji wynosi AnimationTrack.Length (w sekundach).
Jeśli prędkość jest dostosowana, to rzeczywisty czas, jaki zajmie odtwarzanie ścieżki, można obliczyć, dzieląc długość przez prędkość.Prędkość jest ilością bez jednostki.
Prędkość można wykorzystać do powiązania długości animacji z różnymi wydarzeniami w grze (na przykład ponowne ładowanie umiejętności) bez konieczności przesyłania różnych wariantów tej samej animacja.
Właściwość ta jest tylko odczytywana i możesz ją zmienić za pomocą AnimationTrack:AdjustSpeed().
Przykłady kodu
W tym przykładzie załadowano gracza i animację.Długość ścieżki animacji określa, jak długo ścieżka będzie odtwarzać się, jeśli prędkość wynosi 1.Jeśli prędkość jest dostosowana, to rzeczywisty czas, jaki zajmie odtwarzanie ścieżki, można obliczyć, dzieląc długość przez prędkość.
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")Następująca funkcja zagra animację dla określonego czasu trwania.Robi się to poprzez zmianę prędkości animacji na długość animacji podzieloną przez żądaną długość odtwarzania.Można go używać w sytuacjach, w których programista chce odtworzyć standardową animację przez różny czas (na przykład ponowne ładowanie różnych zdolności).
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
Zwraca pozycję w czasie w sekundach, w których AnimationTrack gra w swoją animacjaźródła.Można ustawić, aby skok ścieżki do określonej chwili w animacja.
Pozycja czasowa może zostać ustawiona, aby przejść do określonego punktu w animacja, ale AnimationTrack.Można go również używać w połączeniu z AnimationTrack:AdjustSpeed(), aby zamrozić animację na wybranym punkcie (ustawiając prędkość na 0).
Przykłady kodu
Poniższy przykład kodu zawiera dwie funkcje, które pokazują, w jaki sposób można używać AdjustSpeed i TimePosition, aby zamrozić animację w określonym punkcie.
Pierwsza funkcja zamraża animację w określonym momencie czasu (określonym w sekundach).Drugi zamraża ją w procentach (pomiędzy 0 lub 100) poprzez pomnożenie procentu przez długość ścieżki.
Ponieważ pozycja czasowa nie może być używana, gdy ścieżka animacji nie odtwarza, funkcje sprawdzają, czy animacja się odtwarza, zanim kontynuować.
function freezeAnimationAtTime(animationTrack, timePosition)
if not animationTrack.IsPlaying then
-- Odtwarzaj animację, jeśli nie jest odtwarzana
animationTrack:Play()
end
-- Ustaw prędkość na 0, aby zamrozić animację
animationTrack:AdjustSpeed(0)
-- Przejdź do pożądanego TimePosition
animationTrack.TimePosition = timePosition
end
function freezeAnimationAtPercent(animationTrack, percentagePosition)
if not animationTrack.IsPlaying then
-- Odtwarzaj animację, jeśli nie jest odtwarzana
animationTrack:Play()
end
-- Ustaw prędkość na 0, aby zamrozić animację
animationTrack:AdjustSpeed(0)
-- Przejdź do pożądanego 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
Gdy waga jest ustawiona w AnimationTrack nie zmienia się natychmiast, ale przenosi się z WeightCurrent na AnimationTrack.WeightTarget.Czas potrzebny na wykonanie tego zadania jest określony przez parametr czasu zanikania podany przy odtwarzaniu animacji lub dostosowywaniu wagi.
WeightCurrent można sprawdzić przeciwko AnimationTrack.WeightTarget, aby zobaczyć, czy osiągnięto pożądaną wagę.Zwróć uwagę, że te wartości nie powinny być sprawdzane pod kątem równości z operatorem ==, ponieważ obie te wartości są zmiennymi.Aby sprawdzić, czy WeightCurrent osiągnął docelową wagę, zaleca się sprawdzenie, czy odległość między tymi wartościami jest wystarczająco mała (zobacz przykład kodu poniżej).
System ważenia animacji jest używany do określenia, w jaki sposób AnimationTracks gra o tym samym priorytecie jest miksowana razem.Domyślna waga wynosi jeden, a żadne ruchy nie będą widoczne na AnimationTrack z wagą zerową.Poza, która jest pokazana w dowolnym momencie, jest określana przez średnią ważoną wszystkich Poses i wagę obecną każdego AnimationTrack.W większości przypadków animacje mieszania nie są wymagane, a używanie AnimationTrack.Priority jest bardziej odpowiednie.
Przykłady kodu
Ten przykład kodu ładowuje dwie animacje na lokalnym playerze Humanoid i pokazuje, jak parametr czasu zanikania w AnimationTrack.Play określa czas, jaki zajmuje osiągnięcie przez wagę AnimationTrack jej celu wagi.
Ponieważ WeightCurrent i WeightTarget są zmiennymi, operator == nie może być używany do porównania, zamiast tego bardziej odpowiednie jest sprawdzenie, czy różnica między nimi jest wystarczająco mała, aby zakładać, że odpływ wagi został zakończony.
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) -- losowy czas oczekiwania, aby umożliwić postawienie znaku w miejscu
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 jest właściwością tylko do odczytu, która daje obecną wagę AnimationTrack.Ma domyślną wartość 1 i jest ustawiony, gdy AnimationTrack:Play() , AnimationTrack:Stop() lub AnimationTrack:AdjustWeight() jest wzywany.Gdy waga jest ustawiona w AnimationTrack nie zmienia się natychmiast, ale przenosi się z WeightCurrent na AnimationTrack.WeightTarget.Czas potrzebny na wykonanie tego zadania jest określony przez parametr czasu zanikania podany przy odtwarzaniu animacji lub dostosowywaniu wagi.
WeightCurrent można sprawdzić przeciwko AnimationTrack.WeightTarget, aby zobaczyć, czy osiągnięto pożądaną wagę.Zwróć uwagę, że te wartości nie powinny być sprawdzane pod kątem równości z operatorem ==, ponieważ obie te wartości są zmiennymi.Aby sprawdzić, czy WeightCurrent osiągnął docelową wagę, zaleca się sprawdzenie, czy odległość między tymi wartościami jest wystarczająco mała (zobacz przykład kodu poniżej).
System ważenia animacji jest używany do określenia, w jaki sposób AnimationTracks gra o tym samym priorytecie jest miksowana razem.Domyślna waga wynosi jeden, a żadne ruchy nie będą widoczne na AnimationTrack z wagą zerową.Poza, która jest pokazana w dowolnym momencie, jest określana przez średnią ważoną wszystkich Poses i wagę obecną każdego AnimationTrack.W większości przypadków animacje mieszania nie są wymagane, a używanie AnimationTrack.Priority jest bardziej odpowiednie.
Przykłady kodu
Ten przykład kodu ładowuje dwie animacje na lokalnym playerze Humanoid i pokazuje, jak parametr czasu zanikania w AnimationTrack.Play określa czas, jaki zajmuje osiągnięcie przez wagę AnimationTrack jej celu wagi.
Ponieważ WeightCurrent i WeightTarget są zmiennymi, operator == nie może być używany do porównania, zamiast tego bardziej odpowiednie jest sprawdzenie, czy różnica między nimi jest wystarczająco mała, aby zakładać, że odpływ wagi został zakończony.
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) -- losowy czas oczekiwania, aby umożliwić postawienie znaku w miejscu
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
endMetody
AdjustSpeed
Funkcja ta zmienia AnimationTrack.Speed animacja.Pozytywna wartość prędkości odtwarza animację do przodu, negatywna odtwarza ją do tyłu, a 0 ją wstrzymuje.
Początkowa prędkość ścieżki animacji jest ustawiona jako parametr w AnimationTrack:Play() .Jednak prędkość toru może zostać zmieniona podczas odtwarzania, za pomocą AdjustSpeed.Gdy prędkość jest równa 1, ilość czasu potrzebnego na ukończenie animacji jest równa AnimationTrack.Length (w sekundach).
Kiedy jest dostosowywany, można obliczyć rzeczywisty czas, jaki zajmie odtwarzanie ścieżki, dzieląc długość przez prędkość. Prędkość jest ilością bez jednostki.
Prędkość można wykorzystać do powiązania długości animacji z różnymi wydarzeniami rozgrywkowymi (na przykład ponownym naładowaniem umiejętności) bez konieczności przesyłania różnych wariantów tej samej animacja.
Parametry
Prędkość odtwarzania animacji, którą należy zmienić.
Zwroty
Przykłady kodu
Następująca funkcja zagra animację dla określonego czasu trwania.Robi się to poprzez zmianę prędkości animacji na długość animacji podzieloną przez żądaną długość odtwarzania.Można go używać w sytuacjach, w których programista chce odtworzyć standardową animację przez różny czas (na przykład ponowne ładowanie różnych zdolności).
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)W tym przykładzie załadowano gracza i animację.Długość ścieżki animacji określa, jak długo ścieżka będzie odtwarzać się, jeśli prędkość wynosi 1.Jeśli prędkość jest dostosowana, to rzeczywisty czas, jaki zajmie odtwarzanie ścieżki, można obliczyć, dzieląc długość przez prędkość.
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
Zmienia wagę animacja, z opcjonalnym parametrem czasu trwania określającym, jak długo zajmie AnimationTrack.WeightCurrent dotarcie do AnimationTrack.WeightTarget.
Gdy waga jest ustawiona w AnimationTrack nie zmienia się natychmiast, ale przenosi się z WeightCurrent na AnimationTrack.WeightTarget.Czas potrzebny na wykonanie tego zadania jest określony przez parametr czasu zanikania podany przy odtwarzaniu animacji lub dostosowywaniu wagi.
WeightCurrent można sprawdzić przeciwko AnimationTrack.WeightTarget, aby zobaczyć, czy osiągnięto pożądaną wagę.Zwróć uwagę, że te wartości nie powinny być sprawdzane pod kątem równości z operatorem ==, ponieważ obie te wartości są zmiennymi.Aby sprawdzić, czy WeightCurrent osiągnął docelową wagę, zaleca się sprawdzenie, czy odległość między tymi wartościami jest wystarczająco mała (zobacz przykład kodu poniżej).
System ważenia animacji jest używany do określenia, w jaki sposób AnimationTracks gra o tym samym priorytecie jest miksowana razem.Domyślna waga wynosi jeden, a żadne ruchy nie będą widoczne na AnimationTrack z wagą zerową.Poza, która jest pokazana w dowolnym momencie, jest określana przez średnią ważoną wszystkich Poses i wagę obecną każdego AnimationTrack.Zobacz poniżej przykład łączenia animacji w praktyce.W większości przypadków animacje mieszania nie są wymagane, a używanie AnimationTrack.Priority jest bardziej odpowiednie.
Parametry
Waga, do której ma zostać zmieniona animacja.
Czas trwania animacji, która zniknie między starym ciężarem a nową wagą.
Zwroty
Przykłady kodu
Ten przykład kodu zawiera funkcję, która zmienia wagę ścieżki animacji i generuje do czasu, aż waga zmieni się na nową wagę docelową.
Celem tego przykładu jest pokazanie, jak działa parametr czasu zanikania z AnimationTrack.AdjustWeight.W większości przypadków, jeśli programista chce zrezygnować z czasu trwania, zaleca się, aby użył 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
Funkcja ta zwraca event podobną do wydarzenia AnimationTrack.KeyframeReached, z wyjątkiem, że wystrzeliwuje tylko wtedy, gdy zostanie uderzony określony KeyframeMarker w animation.Różnica pozwala na większą kontrolę, kiedy wydarzenie się wyzwoli.
Aby dowiedzieć się więcej o wykorzystaniu tej funkcji, zobacz Wydarzenia animacji w artykule Edytor animacji.
Zobacz także:
- , przechowuje zastosowany do stawów w danym momencie w animacja
Parametry
Nazwa sygnału, dla którego jest tworzona, nie jest mylona z nazwą .
Zwroty
Sygnał utworzony i wystrzelony, gdy animacja dotrze do stworzonego KeyframeMarker. Nie należy mylić z nazwą Keyframe.
Przykłady kodu
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
Zwraca pozycję czasu pierwszego Keyframe z daną nazwą w AnimationTrack .Jeśli wiele Keyframes dzieli to samo nazwisko, zwróci najwcześniejsze w animacja.
Funkcja ta zwróci błąd, jeśli zostanie użyta z nieprawidłową nazwą kluczowego ramienia (na przykład nie istniejącą) lub jeśli podstawowe Animation nie zostało jeszcze załadowane.Aby rozwiązać ten problem, upewnij się, że używane są tylko poprawne nazwy klatek kluczowych, a animacja została załadowana przed wywołaniem tej funkcji.
Aby sprawdzić, czy animacja się załadowała, sprawdź, czy AnimationTrack.Length jest większe od zera.
Parametry
Zwroty
Przykłady kodu
Ten przykład zawiera funkcję, która skoczy do pierwszego kluczowego kadru określonej nazwy w ścieżce animacji.
Ponieważ pozycja czasu animacji nie może być ustawiona, gdy animacja nie odtwarza funkcji, najpierw sprawdza się, czy animacja się odtwarza.
Ta próbka będzie działać tylko po załadowaniu animacji.
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
Gdy AnimationTrack:Play() jest wzywany, animacja ścieżki zacznie się odtwarzać, a waga animacji wzrośnie z 0 do określonej wagi (domyślnie 1) w określonym czasie trwania animacji (domyślnie 0,1).
Prędkość, z jaką AnimationTrack będzie odtwarzać, jest określana przez parametr prędkości (domyślnie 1).Gdy prędkość jest równa 1, liczba sekund, jakie zajmie ukończenie ścieżki, jest równa właściwości ścieżki AnimationTrack.Length.Na przykład prędkość 2 spowoduje, że tor będzie odtwarzał się dwa razy szybciej.
Waga i prędkość animacji można również zmienić po rozpoczęciu odtwarzania animacji za pomocą metod AnimationTrack:AdjustWeight() i AnimationTrack:AdjustSpeed().
Jeśli programista chce rozpocząć animację w określonym momencie za pomocą AnimationTrack.TimePosition, ważne jest, aby animacja została odtworzona, zanim to się stanie.
Parametry
Czas, przez który waga animacjapowinna zniknąć.
Waga, przy której ma być odtwarzana animacja.
Prędkość odtwarzania animacja.
Zwroty
Przykłady kodu
Następująca funkcja zagra animację dla określonego czasu trwania.Robi się to poprzez zmianę prędkości animacji na długość animacji podzieloną przez żądaną długość odtwarzania.Można go używać w sytuacjach, w których programista chce odtworzyć standardową animację przez różny czas (na przykład ponowne ładowanie różnych zdolności).
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)Poniższy przykład kodu zawiera dwie funkcje, które pokazują, w jaki sposób można używać AdjustSpeed i TimePosition, aby zamrozić animację w określonym punkcie.
Pierwsza funkcja zamraża animację w określonym momencie czasu (określonym w sekundach).Drugi zamraża ją w procentach (pomiędzy 0 lub 100) poprzez pomnożenie procentu przez długość ścieżki.
Ponieważ pozycja czasowa nie może być używana, gdy ścieżka animacji nie odtwarza, funkcje sprawdzają, czy animacja się odtwarza, zanim kontynuować.
function freezeAnimationAtTime(animationTrack, timePosition)
if not animationTrack.IsPlaying then
-- Odtwarzaj animację, jeśli nie jest odtwarzana
animationTrack:Play()
end
-- Ustaw prędkość na 0, aby zamrozić animację
animationTrack:AdjustSpeed(0)
-- Przejdź do pożądanego TimePosition
animationTrack.TimePosition = timePosition
end
function freezeAnimationAtPercent(animationTrack, percentagePosition)
if not animationTrack.IsPlaying then
-- Odtwarzaj animację, jeśli nie jest odtwarzana
animationTrack:Play()
end
-- Ustaw prędkość na 0, aby zamrozić animację
animationTrack:AdjustSpeed(0)
-- Przejdź do pożądanego 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
Parametry
Zwroty
Stop
Zatrzymuje AnimationTrack .Po wezwaniu waga animacji zmierzy się w kierunku zera przez określoną długość czasu za pomocą opcjonalnego parametru fadeTime.Na przykład, jeśli zostanie wezwane z , zajmie to dwa sekundy, aby waga toru osiągnęła zero i jej efekty całkowicie się kończyć.Pamiętaj, że będzie to przypadek niezależnie od początkowej wagi animacja.
Nie zaleca się używania fadeTime z 0 w próbie wyłączenia tego efektu i natychmiast zakończenia animacji dla Motor6Ds tych, które mają ustawiony Motor.MaxVelocity na zero, ponieważ powoduje to zamrożenie stawów w miejscemusi się skończyć natychmiast, upewnij się, że Motor.MaxVelocity z Motor6Ds w twoim układzie jest wystarczająco wysoki, aby można było go prawidłowo przymocować.
Parametry
Czas, w sekundach, na który należy rozpłynąć wagę animacji.
Zwroty
Przykłady kodu
Ten przykład kodu zawiera funkcję, która zatrzymuje animację ścieżki z określonym czasem trwania i zatrzymuje się, dopóki animacja nie zostanie zakończona, a waga ścieżki animacji nie wyniesie zera.
Celem tego przykładu jest pokazanie, jak działa parametr czasu zanikania z AnimationTrack.Stop.W większości przypadków, jeśli programista chce zrezygnować z czasu trwania, zaleca się, aby użył 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)Zdarzenia
DidLoop
To wydarzenie wystrzeliwuje się za każdym razem, gdy pętla AnimationTrack zostanie zakończona, w następnej aktualizacja.
Obecnie może również strzelać dokładnie na końcu niezapętlanej ścieżki animacji, ale to zachowanie nie powinno być traktowane jako pewne.
Przykłady kodu
Funkcja w tym przykładzie kodu zagra animację na pętlu, dla określonej liczby pętli, zanim zatrzyma animację.
W niektórych przypadkach programista może chcieć zatrzymać powtarzającą się animację po zakończeniu pewnej liczby pętli, a nie po pewnym czasie.To jest miejsce, w którym można użyć wydarzenia DidLoop.
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() -- ważne jest odłączenie połączeń, gdy nie są już potrzebne
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
Wypala się, gdy AnimationTrack zostanie całkowicie zakończone przenoszenie czegokolwiek w świecie.Animacja skończyła się odtwarzać, "nan" został zakończony, a temat jest w neutralnej pozie.
Możesz tego użyć, aby podjąć działania, gdy temat ścieżki animacji powróci do neutralnej pozy, która nie jest dotknięta przez AnimationTrack lub oczyścić AnimationTrack.lub jakiekolwiek powiązane połączenia.
Przykłady kodu
Funkcja w tym przykładzie kodu odtwarza animację ścieżki i wykonuje do czasu, aż się zatrzyma i skończy, drukując na każdym kroku w drodze.
local InsertService = game:GetService("InsertService")
local Players = game:GetService("Players")
-- Stwórz model NPC, aby zanimać.
local npcModel = Players:CreateHumanoidModelFromUserId(129687796)
npcModel.Name = "JoeNPC"
npcModel.Parent = workspace
npcModel:MoveTo(Vector3.new(0, 15, 4))
local humanoid = npcModel:WaitForChild("Humanoid")
-- Załaduj animację.
local animationModel = InsertService:LoadAsset(2510238627)
local animation = animationModel:FindFirstChildWhichIsA("Animation", true)
local animator = humanoid:WaitForChild("Animator")
local animationTrack = animator:LoadAnimation(animation)
-- Połącz z wydarzeniem Zatrzymany. To się uruchamia, gdy animacja się zatrzymuje
-- jest własnym porozumieniem, albo wyraźnie nazywamy Stop.
animationTrack.Stopped:Connect(function()
print("Animation stopped")
end)
-- Połącz z wydarzeniem zakończonym. To się uruchamia, gdy animacja jest całkowicie zakończona
-- zakończyło wpływanie na świat. W tym przypadku strzeli 3 sekund
-- po wezwaniu animacjiTrack:Stop, ponieważ przekazujemy 3
-- drugi odpływ.
animationTrack.Ended:Connect(function()
print("Animation ended")
animationTrack:Destroy()
end)
-- Biegnij, daj mu trochę do gry, a potem się zatrzymaj.
print("Calling Play")
animationTrack:Play()
task.wait(10)
print("Calling Stop")
animationTrack:Stop(3)KeyframeReached
Wybucha za każdym razem, gdy odtwarzanie AnimationTrack osiąga Keyframe, które nie ma domyślnej nazwy - "Keyframe".
To wydarzenie pozwala programiście uruchomić kod w określonych punktach animacji (ustawionych przez nazwy Keyframe).Umożliwia to rozszerzenie domyślnej funkcjonalności animacji Roblox poprzez dodanie Sounds lub ParticleEffects w różnych punktach animacja.
Keyframe nazwy nie muszą być unikalne.Na przykład, jeśli animacja ma trzy kluczowe ramy o nazwie "Cząsteczki", wydarzenie KeyframeReached zostanie uruchomione za każdym razem, gdy jeden z tych kluczowych ram zostanie osiągnięty.
Keyframe nazwy można ustawić w edytorze animacji Roblox podczas tworzenia lub edytowania animacja.Nie mogą jednak zostać ustawione przez Script na istniejącej animacji przed jej odtworzeniem.
Parametry
Stopped
Wybucha za każdym razem, gdy AnimationTrack kończy odtwarzanie.
To wydarzenie ma wiele zastosowań.Można go użyć, aby poczekać, aż AnimationTrack przestanie się kręcić, zanim kontynuować (na przykład, jeśli łączysz serię animacji, aby grać po sobie nawzajem).Można go również użyć do oczyszczenia dowolnego Instances utworzonego podczas odtwarzania animacji.
Przykłady kodu
Funkcja w tym przykładzie kodu odtworzy animację ścieżki i wyda, dopóki się nie zatrzyma, przed wydrukowaniem.
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)