6. Łączenie ruchu, obrotu i skali

Gdy mamy już obiekty, które się poruszają, obracają lub skalują, kolejnym krokiem jest połączenie wszystkich tych efektów razem. Tworzenie animacji rekwizytów, które poruszają się jednocześnie na różne sposoby, wiąże się z nowymi wyzwaniami.

Kontroler animacji może odtworzyć tylko jedną animację w danym momencie, dlatego nie możesz wykonać ruchu, obrotu i skalowania w oddzielnych animacjach. Te animacje potrzebują również wielu klatek kluczowych, ponieważ możesz chcieć obrócić rekwizyt wiele razy w trakcie każdej animacji. Wszystkie klatki kluczowe musisz utworzyć z wyprzedzeniem, dlatego trzeba też obliczyć pozycję, obrót i skalę w każdym punkcie drogi rekwizytu. Co się stanie, jeśli rekwizyt nie wykona parzystej liczby obrotów? Jak zrealizować pół obrotu?

W kolejnej sekcji będzie dużo matematyki. Na koniec jednak będziesz poruszać rekwizytami, obracać je i skalować do wielu punktów oraz kreować złożone, dynamiczne i (co najważniejsze!) atrakcyjne wyzwania platformowe, aby utworzyć tor Fall Guys, jaki ci się zamarzy.

Budowanie animacji, które się poruszają, obracają i skalują

Wykonaj poniższe kroki, aby zacząć łączyć wszystko razem:

1. Utwórz nową klasę Verse o nazwie animating_prop, która dziedziczy z movable_prop przy użyciu Eksploratora Verse. Do tej klasy dodaj specyfikator <concrete>, aby uwidocznić jej właściwości dla UEFN.

   Verse

        # A prop that translates, rotates, and scales to a destination using animation.
        animating_prop<public> := class<concrete>(movable_prop):

   Copy full snippet(2 lines long)

2. Dodaj instrukcje using { /Fortnite.com/Devices/CreativeAnimation } i using { /UnrealEngine.com/Temporary/SpatialMath } na początku pliku, aby zaimportować te moduły. Są one potrzebne, aby animować rekwizyt. W tym miejscu dołączono podpowiedzi użyte w tej sekcji.

   Verse

        using { /Fortnite.com/Devices }
        using { /Fortnite.com/Devices/CreativeAnimation }
        using { /Verse.org/Simulation }
        using { /UnrealEngine.com/Temporary/SpatialMath }
   
        RotationRateTip<localizes>:message := "The time it takes to make one AdditionalRotation in seconds."
        UseEasePerKeyframeTip<localizes>:message := "Whether this prop should use the MoveEaseType for each keyframe. False will use the Linear ease type on each frame."
   
        # A prop that translates, rotates, and scales to a destination using animation.
        animating_prop<public> := class<concrete>(movable_prop):

   Copy full snippet(10 lines long)

3. Na początku definicji klasy animating_prop dodaj następujące pola:

   1. Edytowalny obrót o nazwie AdditionalRotation. Jest to obrót, który ma być zastosowany do RootProp na każdą klatkę kluczową.

      Verse

       # The additional rotation to apply to the RootProp per keyframe.
       @editable {ToolTip := AdditionalRotationTip}
       AdditionalRotation:rotation = rotation{}
      

      Copy full snippet(3 lines long)

   2. Edytowalna wartość zmiennopozycyjna o nazwie RotationRate. Jest to wyrażona w sekundach ilość czasu, przez jaką trwa wykonanie jednego AdditionalRotation.

      Verse

       # The time it takes to make one AdditionalRotation in seconds.
       @editable {ToolTip := RotationRateTip}
       var RotationRate:float = 1.0
      

      Copy full snippet(3 lines long)

   3. Edytowalna wartość logiczna o nazwie UseEasePerKeyFrame. Określa to, czy każda klatka kluczowa do interpolacji używa MoveEaseType. W tym przykładzie ustawienie tej opcji na false spowoduje, że domyślnie dla każdej klatki będzie używany liniowy typ interpolacji.

      Verse

       # Whether this prop should use the MoveEaseType per each frame of animation.
       # Setting this to false will use the linear MoveEaseType on each frame.
       @editable
       UseEasePerKeyframe:logic = true
      

      Copy full snippet(4 lines long)

   4. Edytowalna tablica creative_prop o nazwie MoveTargets. Istnieją różne rekwizyty Trybu kreatywnego, w których kierunku będzie się przemieszczał rekwizyt główny.

      Verse

       # The Creative prop target for the RootProp to move toward.
       @editable {ToolTip := MoveTargetsTip}
       var MoveTargets:[]creative_prop = array{}
      

      Copy full snippet(3 lines long)

   5. Przekształcenie zmiennej o nazwie TargetTransform . Jest to przekształcenie, do którego aktualnie dąży rekwizyt nadrzędny.

      Verse

       # The transform the prop is currently targeting.
       var TargetTransform:transform = transform{}
      

      Copy full snippet(2 lines long)

4. Definicja klasy powinna wyglądać następująco:

   Verse

        using { /Fortnite.com/Devices }
        using { /Fortnite.com/Devices/CreativeAnimation }
        using { /Verse.org/Simulation }
        using { /UnrealEngine.com/Temporary/SpatialMath }
   
        RotationRateTip<localizes>:message := "The time it takes to make one AdditionalRotation in seconds."
        UseEasePerKeyframeTip<localizes>:message := "Whether this prop should use the MoveEaseType for each keyframe. False will use the Linear ease type on each frame."
   
        # A prop that translates, rotates, and scales to a destination using animation.
        animating_prop<public> := class<concrete>(movable_prop):
   
   Expand code Copy full snippet(32 lines long)

5. Zastąp funkcję Move() w klasie animating_prop. Następnie w wyrażeniu for wykonaj iterację przez każdy MoveTarget w tablicy MoveTargets. Sprawdź, czy każdy MoveTarget jest prawidłowy, a jeśli tak, ustaw TargetTransform na przekształcenie MoveTarget.

   Verse

        # Move and rotate the RootProp toward the MoveTarget, or MoveTransform if one is set.
        Move<override>()<suspends>:void=
   
            # Move to each target in the MoveTargets array.
            for:
                MoveTarget:MoveTargets
            do:
   
                # Set the TargetTransformto the MoveTarget if the
                # MoveTarget is set. Otherwise set it to the MoveTransform.
   
   Expand code Copy full snippet(14 lines long)

6. Wróć do pliku movement_behaviors i dodaj do niego nową metodę o nazwie BuildMovingAnimationKeyframes(). Ta funkcja utworzy i zwróci tablicę klatek kluczowych, które animują rekwizyt, poruszając nim i obracając go do przekształcenia docelowego. Ta funkcja przyjmuje kilka parametrów z animating_prop – MoveDuration, RotationRate, AdditionalRotation, OriginalTransform (przekształcenie początkowe rekwizytu), TargetTransform, MoveEaseType i nową wartość logiczną o nazwie UseEasePerKeyframe. Określa to, czy dla każdej klatki kluczowej używasz MoveEaseType. Sygnatura funkcji powinna wyglądać następująco:

   Verse

        # Builds an array of keyframes that animate movement and rotation from the OriginalTransform to the TargetTransform.
        BuildMovingAnimationKeyframes(MoveDuration:float, RotationRate:float, AdditionalRotation:rotation, OriginalTransform:transform, TargetTransform:transform,MoveEaseType:move_to_ease_type, UseEasePerKeyframe:logic):[]keyframe_delta=
   

   Copy full snippet(2 lines long)

7. W BuildMovingAnimationKeyframes(), inicjowanie następujących zmiennych:

   1. Tablica keyframe_delta zmiennej o nazwie Keyframes. Jest to tablica, którą zwrócisz na końcu.

      Verse

       # The array of keyframes to return.
       var KeyFrames:[]keyframe_delta = array{}
      

      Copy full snippet(2 lines long)

   2. Wartość zmiennopozycyjna zmiennej o nazwie TotalTime. Łączna ilość czasu poświęcona na animację do danego momentu.

      Verse

       # The total amount of time spent animating.
       var TotalTime:float = 0.0
      

      Copy full snippet(2 lines long)

   3. Dwie zmienne transform o nazwach StartTransform i EndTransform. Są to początkowe i końcowe przekształcenia rekwizytu na początku i na końcu każdej klatki kluczowej. Zainicjuj obie na OriginalTransform.

      Verse

       # The starting transform for building keyframes. This is the
       # transform of the RootProp at the start of each keyframe.
       var StartTransform:transform = OriginalTransform
      
       # The ending transform for building keyframes. This is the
       # transform of the RootProp at the end of each keyframe.
       var EndTransform:transform = OriginalTransform
      

      Copy full snippet(7 lines long)

   4. Obrót zmiennej o nazwie RotationToApply, zainicjowany na AdditionalRotation. Jest to faktyczny obrót, który będzie zastosowany do rekwizytu dla każdej klatki kluczowej. Zwykle będzie to AdditionalRotation, ale jeśli potrzebujesz obrotu ułamkowego, zmień tę wartość.

      Verse

       # The actual rotation to apply to the RootProp. Usually this is the
       # AdditionalRotation, but will change in cases with fractional rotations.
       var RotationToApply:rotation = AdditionalRotation
      

      Copy full snippet(3 lines long)

   5. Wartość zmiennopozycyjna zmiennej o nazwie AnimationTime. Czas trwania każdej klatki kluczowej w sekundach. Zainicjuj na 1.0 / RotationRate, ponieważ RootProp musi wykonać liczbę obrotów na sekundę równą RotationRate.

      Verse

       # The time it takes for each keyframe of animation to complete.
       # This is initialized to 1.0/Rotation rate since the RootProp needs to make a
       # RotationRate number of rotations per second.
       var AnimationTime:float = 1.0 / RotationRate
      

      Copy full snippet(4 lines long)

   6. Wartość zmiennopozycyjna o nazwie TotalRotations. Jest to łączna liczba obrotów, które mają być wykonane w trakcie całej animacji, zainicjowana na MoveDuration * RotationRate. Dzieje się tak dlatego, że w sytuacjach, w których nie trzeba wykonywać całego obrotu, np. na końcu animacji, używa się wartości float, a nie int.

      Verse

       # The total number of rotations to make.
       TotalRotations:float = MoveDuration * RotationRate
      

      Copy full snippet(2 lines long)

   7. Wartość zmiennopozycyjna o nazwie TimePerRotation. Czas wykonania jednego pełnego obrotu w sekundach. Funkcja powinna wyglądać następująco:

      Verse

       # Builds an array of keyframes that animate movement and rotation from the OriginalTransform to the TargetTransform.
       BuildMovingAnimationKeyframes(MoveDuration:float, RotationRate:float, AdditionalRotation:rotation, OriginalTransform:transform, TargetTransform:transform,MoveEaseType:move_to_ease_type, UseEasePerKeyframe:logic):[]keyframe_delta=
      
           # The array of keyframes to return.
           var KeyFrames:[]keyframe_delta = array{}
      
           # The total amount of time spent animating.
           var TotalTime:float = 0.0
      
           # The starting transform for building keyframes. This is the
      
      Expand code Copy full snippet(31 lines long)

Trzeba pamiętać o wielu wartościach, dlatego wykonajmy przykładowe obliczenie, używając 2.5 jako RotationRate i 5.0 jako MoveDuration.

    Rotation Rate = 2.5 rotations/second

    Move Duration = 5.0 seconds

    Animation Time = 
        1.0 seconds/Rotation Rate = 
        1.0/2.5 = 0.4 seconds

    Total Rotations = 
        Move Duration /Rotation Rate = 

Z RotationRate 2.5 i MoveDuration 5.0, wykonasz w sumie 12.5 obrotu, przy czym każdy obrót zajmie 0.4 sekundy. Oznacza to, że trzeba będzie dodać dodatkowe pół obrotu na końcu animacji. Zwróć uwagę, że czas animacji i czas na każdy obrót są takie same. Dzieje się tak prawie zawsze, z wyjątkiem sytuacji, w których trzeba wykonać mniej niż pełny obrót. Początkowo mają tę samą wartość, ale trzeba śledzić obie zmienne, aby później wykonać pewne obliczenia matematyczne.

Budowanie klatek kluczowych w pętli

Czas rozpocząć budowanie! Wykonaj poniższe kroki, aby skonfigurować pętlę, która tworzy klatki kluczowe.

1. Dodaj wyrażenie loop (pętla) do BuildMovingAnimationKeyframes(). Przy każdym powtórzeniu pętli zbudujesz nową klatkę kluczową i dodasz ją do tablicy klatek kluczowych. Na początku pętli zaktualizuj TotalTime o TimePerRotation.

   Verse

        # Build each keyframe of animation and add it to the Keyframes array.
        # The loop breaks when the TotalTime goes past the MoveDuration.
        loop:
            # Add the TimePerRotation to the TotalTime.
            set TotalTime += TimePerRotation
   

   Copy full snippet(5 lines long)

2. Skompiluj EndTransform, czyli miejsce, w którym rekwizyt powinien znajdować się na końcu tej klatki kluczowej. Ustaw EndTransform na nowe przekształcenie z następującymi parametrami:

   1. Ustaw Translation na wynik wywołania Lerp() między OriginalTransform i TargetTransform. Funkcja Lerp() przyjmuje dwie wartości i współczynnik Lerp pomiędzy 0.0 a 1.0. Następnie generuje nową wartość z zakresu między dwiema wartościami na podstawie współczynnika Lerp. Im współczynnik Lerp jest bliższy 1.0, tym bliższe będzie przekształcenie TargetTransform i odwrotnie.

      Verse

       # Build the ending transform for the RootProp to move to.
       set EndTransform = transform:
           # Use Lerp() to find how far between the StartingTransform and the TargetTransform the RootProp should translate.
           # Do the same for scale, and rotate the starting transform by the RotationToApply.
           # The Lerp Parameter is based on the total number of rotations since the RootProp should guarantee that it makes
           # at least that many rotations over the whole animation.
           Translation := Lerp(OriginalTransform.Translation, TargetTransform.Translation, (TotalTime * RotationRate) / (TotalRotations))
      

      Copy full snippet(7 lines long)

   2. Ustaw Rotation na wynik MakeShortestRotationBetween(), przekazując obrót początkowego przekształcenia oraz początkowe przekształcenie obrócone o wartość RotationToApply.

      Verse

       Translation := Lerp(OriginalTransform.Translation, TargetTransform.Translation, (TotalTime * RotationRate) / (TotalRotations))
       Rotation := MakeShortestRotationBetween(OriginalTransform.Rotation, OriginalTransform.Rotation.RotateBy(RotationToApply))~~~
      

      Copy full snippet(2 lines long)

   3. Ustaw metodę Scale na wynik wywołania Lerp() między OriginalTransform.Scale i TargetTransform.Scale. Pamiętaj, że jest to skala, do której rekwizyt ma się przeskalować, a nie wielkość, o jaką ma być przeskalowany. Gotowy kod EndTransform powinien wyglądać następująco:

      Verse

       # Build the ending transform for the RootProp to move to.
       set EndTransform = transform:
           # Use Lerp() to find how far between the StartingTransform and the TargetTransform the RootProp should translate.
           # Do the same for scale, and find the shortest rotation between the original transform and a rotation to apply to it.
           Translation := Lerp(OriginalTransform.Translation, TargetTransform.Translation, LerpParameter)  
           Rotation := MakeShortestRotationBetween(OriginalTransform.Rotation, OriginalTransform.Rotation.RotateBy(RotationToApply))   
           Scale := Lerp(OriginalTransform.Scale, TargetTransform.Scale, LerpParameter)    
      

      Copy full snippet(7 lines long)

3. Po ustawieniu przekształcenia końcowego czas utworzyć klatkę kluczową! Zasadniczo proces jest taki sam, jak w przypadku funkcji MoveToEase(). Utwórz nową zmienną keyframe_delta o nazwie KeyFrame. Ustaw DeltaLocation na różnicę między translacjami przekształcenia końcowego i początkowego. Ustaw DeltaRotation na obrót przekształcenia końcowego. Musisz obliczyć zmianę skali, dlatego ustaw DeltaScale na iloraz skali przekształcenia końcowego i skali przekształcenia początkowego. Wartość Time powinna być wartością AnimationTime, a wartość InterpolationType powinna być wynikiem wyrażenia if. Jeśli UseEasePerKeyframe ma wartość true, użyj MoveEaseType. W przeciwnym razie użyj typu liniowego. Wyrażenie klatki kluczowej powinno wyglądać następująco:

   Verse

        # Build the animation keyframe to animate the RootProp.
        Keyframe := keyframe_delta:
            DeltaLocation := EndTransform.Translation - StartTransform.Translation,
            DeltaRotation := EndTransform.Rotation,
            DeltaScale := EndTransform.Scale/StartTransform.Scale,
            Time := AnimationTime,
            # Use the MoveEaseType for interpolation if UseEasePerKeyframe is true,
            # otherwise use the Linear movement type.
            Interpolation :=
                if:
   
   Expand code Copy full snippet(15 lines long)

4. Po utworzeniu klatki kluczowej możesz dodać ją do tablicy klatek kluczowych. Następnie ustaw StartTransform na EndTransform, aby zaktualizować go dla następnej klatki kluczowej. Na koniec, jeśli TotalTime jest teraz większe niż MoveDuration, przerwij pętlę.

   Verse

        # Add the new keyframe to the KeyFrames array, and set the
        # StartTransform to the EndTransform.
        set Keyframes += array{Keyframe}
        set StartTransform = EndTransform
        # Break out of the loop if the TotalTime passes the MoveDuration.
        if:
            TotalTime >= MoveDuration
        then:
            break
   

   Copy full snippet(9 lines long)

5. Rozważmy jeszcze ważny przypadek krańcowy: co się dzieje, gdy chcesz wykonać mniej niż pełny obrót? Dodajesz TimePerRotation do TotalTime, dlatego na początku pętli TotalTimemoże być dłuższy niż MoveDuration. W tej sytuacji musisz wykorzystać pozostały czas i, aby uwzględnić różnicę, wykonać mniej niż pełny obrót z krótszym czasem animacji. Aby uwzględnić taki przypadek, wykonaj poniższe kroki:

   1. Wróć do początku pętli i po aktualizacji TotalTime uruchom wyrażenie if. Wewnątrz tego wyrażenia zainicjuj zmienną LeftoverTime i ustaw ją tak, aby była równa wynikowi odejmowania TotalTime i MoveDuration, sprawdzając, czy wynik jest większy od 0.0. To wyrażenie przypisze LeftoverTime tylko wtedy, gdy porównanie będzie miało wartość true.

      Verse

       loop:
           # Add the TimePerRotation to the TotalTime.
           set TotalTime += TimePerRotation
           if:
               # If the TotalTime is greater than the MoveDuration, the final keyframe needs
               # to be shortened. This means making a fraction of a rotation.
               LeftoverTime := TotalTime - MoveDuration > 0.0
      

      Copy full snippet(7 lines long)

   2. Aby dowiedzieć się, jaki ułamek obrotu musisz wykonać, zainicjuj nową zmienną Frakcja obrotu, i ustaw ją równą różnicy między TimePerRotation a LeftoverTime, wszystko podzielone przez TimePerRotation.

      Verse

       if:
           # If the TotalTime is greater than the MoveDuration, the final keyframe needs
           # to be shortened. This means making a fraction of a rotation.
           LeftoverTime := TotalTime - MoveDuration > 0.0
      
           # The fraction of a rotation to make.
           RotationFraction := (TimePerRotation - LeftoverTime)/TimePerRotation
      

      Copy full snippet(7 lines long)

   3. Aby utworzyć zmodyfikowany obrót z RotationFraction, użyjesz Slerp[]. To jest wersja Lerp(), która obsługuje interpolację sferyczną i ma podobne parametry. Znajduje najkrótszy obrót między dwoma różnymi obrotami i zwraca obrót na podstawie parametru interpolacji liniowej. Wywołaj Slerp[], interpolując między IdentityRotation() i IdentityRotation() obróconym o RotationToApply, używając RotationFraction jako parametru interpolacji liniowej. Używasz tutaj IdentityRotation(), ponieważ interesuje cię tylko, jaki obrót ułamkowy masz zastosować, a nie w jakim obrocie końcowym ma być EndTransform.

      Verse

       set TotalTime += TimePerRotation
       if:
           # If the TotalTime is greater than the MoveDuration, the final keyframe needs
           # to be shortened. This means making a fraction of a rotation.
           LeftoverTime := TotalTime - MoveDuration > 0.0
      
           # The fraction of a rotation to make.
           RotationFraction := (TimePerRotation - LeftoverTime)/TimePerRotation
      
           # Make a modified fractional rotation by using Slerp(). The Slerp() function does spherical interpolation
      
      Expand code Copy full snippet(12 lines long)

   4. Po skonfigurowaniu tych wartości ustaw RotationToApply na ModifiedRotation, pomnóż AnimationTime przez RotationFraction, aby się dowiedzieć, o ile skrócić animację, na koniec ustaw TotalTime na MoveDuration, ponieważ nie chcesz, aby był dłuższy niż w przypadku obliczania EndTransform.

      Verse

           ModifiedRotation := Slerp[IdentityRotation(),  IdentityRotation().RotateBy(RotationToApply), RotationFraction]
       then:
           # Set the RotationToApply to the modified rotation, and multiply the animation time by
           # the RotationFraction to get the modified animation time.
           set RotationToApply = ModifiedRotation
           set AnimationTime = AnimationTime * RotationFraction
           # Since the TotalTime should not go past the MoveDuration,
           # set TotalTime to MoveDuration.
           set TotalTime = MoveDuration
      

      Copy full snippet(9 lines long)

6. Na samym końcu funkcji, po pętli, zwróć tablicę Keyframes. Gotowa funkcja BuildMovingAnimationKeyframes() powinna wyglądać następująco:

   Verse

        # Builds an array of keyframes that animate movement and rotation from the OriginalTransform to the TargetTransform.
        BuildMovingAnimationKeyframes(MoveDuration:float, RotationRate:float, AdditionalRotation:rotation, OriginalTransform:transform, TargetTransform:transform,MoveEaseType:move_to_ease_type, UseEasePerKeyframe:logic):[]keyframe_delta=
   		
            # The array of keyframes to return.
            var Keyframes:[]keyframe_delta = array{}
   		
            # The total amount of time spent animating.
            var TotalTime:float = 0.0
   		
            # The starting transform for building keyframes. This is the
   
   Expand code Copy full snippet(97 lines long)

7. Po zdefiniowaniu logiki tworzenia klatek kluczowych czas utworzyć ich animację. Do utworzenia i wywołania animacji użyjesz osobnej funkcji. Dodaj nową funkcję BuildAndPlayAnimation() do klasy animating_prop. Do tej funkcji dodaj modyfikator <suspends>, aby mogła wywoływać inne asynchroniczne funkcje.

   Verse

        # Builds an animation from an array of keyframes, then calls MoveToEase()
        # to animate the prop.
        BuildAndPlayAnimation()<suspends>:void=

   Copy full snippet(3 lines long)

8. W BuildAndPlayAnimation() zainicjuj nową tablicę keyframe_delta o nazwie Keyframes. Następnie ustaw Keyframes na wynik wywołania BuildMovingAnimationKeyframes(). Jako przekształcenie początkowe użyj RootProp.GetTransform(), ponieważ pozycja rekwizytu będzie się zmieniać między wywołaniami Move(). Zainicjuj zmienną animation_mode na animation_mode.OneShot i wywołaj MoveToEase(), przekazując tablicę Keyframes i AnimationMode.

   Gotowa funkcja BuildAndPlayAnimation() powinna wyglądać następująco:

   Verse

    # Builds an animation from an array of keyframes, then calls MoveToEase()
    # to animate the prop.
    BuildAndPlayAnimation()<suspends>:void=
        var Keyframes:[]keyframe_delta = array{}
   
        # Build the animation, using the RootProp as the target transform.
        set Keyframes = BuildMovingAnimationKeyframes(MoveDuration, RotationRate, AdditionalRotation, RootProp.GetTransform(), TargetTransform, MoveEaseType, UseEasePerKeyframe)
   
        # Set the animation mode to OneShot.
        var AnimationMode:animation_mode := animation_mode.OneShot
   
   Expand code Copy full snippet(13 lines long)

9. Wróć do Move() i wywołaj BuildAndPlayAnimation() po ustawieniu TargetTransform na Przekształć cele ruchu.

   Verse

        # Move to each target in the MoveTargets array.
        for:
            MoveTarget:MoveTargets
        do:
            # Set the TargetTransform to the MoveTarget if the
            # MoveTarget is set. Otherwise set it to the MoveTransform.
            if:
                MoveTarget.IsValid[]
            then:
                set TargetTransform = MoveTarget.GetTransform()
   
   Expand code Copy full snippet(12 lines long)

Jest jeszcze jedna sprawa. Co się stanie, jeśli nie ustawisz żadnych celów ruchu? W takiej sytuacji rekwizyt powinien się dalej obracać w miejscu, nie przemieszczając się do nowej pozycji docelowej. Aby to obsłużyć, dodaj wyrażenie if na początku funkcji Move(). W if sprawdź, czy MoveTargets.Length = 0, jeśli tak jest, ustaw TargetTransform na przekształcenie rekwizytu głównego. Następnie wywołaj BuildAndPlayAnimation(). Dzięki temu rekwizyt będzie dalej animowany, nawet jeśli nie ustawisz celu ruchu. Ukończona animacja Move() powinna wyglądać następująco:

    # Move and rotate the RootProp toward the MoveTarget, or MoveTransform if one is set.
    Move<override>()<suspends>:void=
        # If there are no targets to move to, this prop will rotate in place.
        if:
            MoveTargets.Length = 0
        then:
            set TargetTransform = RootProp.GetTransform()

            # Build and play the animation.
            BuildAndPlayAnimation()

Teraz musisz utworzyć odwołanie do animating_prop w swojej klasie prop_animator. W prop_animator dodaj edytowalną tablicę animating_prop o nazwie MoveAndRotateProps. W OnBegin(), w innym wyrażeniu for zainicjuj każdy rekwizyt w MoveAndRotateProps, wywołując Setup(). Gotowa klasa prop_animator powinna wyglądać następująco:

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation }
    using { /UnrealEngine.com/Temporary/Diagnostics }

    TranslatingPropsTip<localizes>:message = "The props that translate (move) using animation."
    RotatingPropsTip<localizes>:message = "The props that rotate using animation."
    ScalingPropsTip<localizes>:message = "The props that scale using animation."
    AnimatingPropsTip<localizes>:message = "The props that both move and rotate using animation."

    # Coordinates moving props through animation by calling each movable_prop's Setup() method.

Zapisz kod i go skompiluj.

Gratulacje, kod jest gotowy! Czas połączyć wszystko razem.

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/CreativeAnimation }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

EasingCategory<localizes>:message := "These control the type of movement easing applied to the prop."
LogicCategory<localizes>:message := "These control different aspects of the prop's logic."
PropsCategory<localizes>:message := "These are the props that move associated with this device."
RotationCategory<localizes>:message := "These control how the prop rotates."
TimingCategory<localizes>:message := "These control the timing of parts of the prop's movmement."

Łączenie rekwizytów z urządzeniami

Wróć do edytora, usuń sekcję toru po sekcji obracania rekwizytów, aby utworzyć lukę przed celem końcowym. Do poziomu dodaj kolejne FG01 SpinningBar Double S i FG01 Hover Platform M. Nadaj im nazwę SpinningMovingBar i TranslatingPlatform, a następnie dodaj kilka rekwizytów żarówki przycisku FG01, które będą elementami docelowymi, do których będzie przenoszony każdy rekwizyt. Nadaj im nazwę PlatformTarget. Umieść platformy i poprzeczkę nad luką, i pamiętaj, aby umieścić cele, do których platformy mają się przemieszczać. W tym przykładzie wirująca poprzeczka porusza się z boku na bok, a platforma porusza się do przodu i do tyłu.

Konfiguracja obracającego się paska i ruchomej platformy. Strzałki wskazują kierunki ruchu każdego rekwizytu. Poprzeczka i platforma poruszają się do przodu i do tyłu, przy czym w trakcie ruchu poprzeczka wiruje.

Wybierz swojego animatora rekwizytów w Outlinerze. Dodaj element tablicy do AnimatingProps dla obracającego się paska. Poszczególne wartości skonfiguruj w następujący sposób:

Dla ruchomej platformy dodaj kolejny element tablicy do TranslatingProps. Przypisz MoveTargets do swojej platformy docelowej, a RootProp do TranslatingPlatform.

Naciśnij Uruchom sesję i spróbuj pokonać ukończony tor przeszkód!

Praca własna

Gotowe! Masz już wszystko, czego potrzebujesz, aby utworzyć własny tor przeszkód Fall Guys przy użyciu Verse!

Możesz użyć tego kodu, aby animować rekwizyty trybu kreatywnego w dowolnej swojej przygodzie, również w projektach innych niż Fall Guys!

Wykorzystując zdobytą wiedzę, spróbuj wykonać następujące czynności:

• Twórz przeszkody, które obracają się w różnych kierunkach lub obracają się losowo na poziomie różnych klatek kluczowych.

• Twórz przeszkody, które aktywują się tylko wtedy, gdy gracz na nich stanie lub podejdzie do nich na określoną odległość.

• Opracuj platformy, które znikają po określonym czasie lub przenoszą gracza do niebezpiecznej pozycji, jeśli za długo stoi w miejscu.

Complete Code

Oto kompletny kod zbudowany w tej sekcji, łącznie z przykładową refaktoryzacją dla animating_prop.

movable_prop.verse

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

MoveDurationTip<localizes>:message = "The amount of time the prop takes to move to its destination."
MoveEaseTypeTip<localizes>:message = "The animation easing applied to the movement."
MoveEndDelayTip<localizes>:message = "The delay after the movement finishes."
MoveOnceAndStopTip<localizes>:message = "Whether the RootProp should stop in place after it finishes moving."
MoveStartDelayTip<localizes>:message = "The delay before the movement starts."
MoveTargetsTip<localizes>:message = "The array of CreativeProp to move toward. These targets can be children of the RootProp."

translating_prop.verse

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/CreativeAnimation }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

MovePositionTip<localizes>:message = "The optional position to move to World Space. Use this if you do not want to set a MoveTarget."

# A prop that moves (translates) toward either a Creative prop target
# or a position in world space.
translating_prop<public> := class<concrete>(movable_prop):

rotating_prop.verse

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/CreativeAnimation }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

AdditionalRotationTip<localizes>:message = "The rotation to apply to the RootProp."
ShouldRotateForeverTip<localizes>:message = "Whether the RootProp should rotate forever."
MatchRotationTargetTip<localizes>:message = "The optional prop whose rotation the RootProp should rotate to. Use this if you do not want to set an Additional Rotation."

# A prop that rotates by an additional rotation or rotates to match

scaling_prop.verse

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/CreativeAnimation }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

MatchScaleTargetTip<localizes>:message = "The optional position to move to World Space. Use this if you do not want to set a MoveTarget."

# A prop that scales toward either a given scale or a Creative prop's scale.
scaling_prop<public> := class<concrete>(movable_prop):
    # The array of vector3 targets for the RootProp to scale to.

animating_prop.verse

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/CreativeAnimation }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

RotationRateTip<localizes>:message := "The time it takes to make one AdditionalRotation in seconds."
UseEasePerKeyframeTip<localizes>:message := "Whether this prop should use the MoveEaseType for each keyframe. False will use the Linear ease type on each frame."

# A prop that translates, rotates, and scales to a destination using animation.
animating_prop<public> := class<concrete>(movable_prop):

movement_behaviors.verse

# This file stores functions common to animating Creative props using keyframes.
# It also defines the move_to_ease_type enum to help in building animations.

using { /Fortnite.com/Devices }
using { /UnrealEngine.com/Temporary/SpatialMath }
using { /Fortnite.com/Characters}
using { /Fortnite.com/Devices/CreativeAnimation }

# Represents the different movement easing types.
move_to_ease_type<public> := enum {Linear, Ease, EaseIn, EaseOut, EaseInOut}

prop_animator.verse

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

TranslatingPropsTip<localizes>:message = "The props that translate (move) using animation."
RotatingPropsTip<localizes>:message = "The props that rotate using animation."
ScalingPropsTip<localizes>:message = "The props that scale using animation."
MoveAndRotatePropsTip<localizes>:message = "The props that both move and rotate using animation."

# Coordinates moving props through animation by calling each moveable_prop's Setup() method.

animating_props.verse (przykładowa refaktoryzacja animating_prop)

using { /Fortnite.com/Devices }
using { /Fortnite.com/Devices/CreativeAnimation }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/SpatialMath }

EasingCategory<localizes>:message := "These control the type of movement easing applied to the prop."
LogicCategory<localizes>:message := "These control different aspects of the prop's logic."
PropsCategory<localizes>:message := "These are the props that move associated with this device."
RotationCategory<localizes>:message := "These control how the prop rotates."
TimingCategory<localizes>:message := "These control the timing of parts of the prop's movmement."