6. Kombinieren von Bewegung, Drehung und Skalierung

Bisher haben wir Objekte sich bewegen, drehen oder skalieren lassen und alles drei gleichzeitig. Es gibt aber einige wichtige Herausforderungen, die berücksichtigt werden müssen, wenn Animationen für Props erstellt werden, die sich gleichzeitig auf verschiedene Arten bewegen.

Da der Animationscontroller nur jeweils eine Animation wiedergeben kann, kannst du nicht die Bewegung, Rotation und Drehung in separaten Animationen durchführen. Diese Animationen benötigen außerdem mehrere Keyframes, da du möglicherweise ein Prop mehrmals pro Animation drehen möchtest. Da du alle Keyframes vorab erstellen musst, musst du außerdem die Position, Rotation und Skalierung an jedem Punkt des Weges des Prop berechnen. Was passiert, wenn dein Prop keine gerade Anzahl von Drehungen durchführt? Wie gehst du mit einer halben Drehung um?

In dem nächsten Abschnitt kommt viel Mathematik vor, aber am Ende wirst du Props mit mehreren Punkten bewegen, drehen und skalieren können und komplex, dynamische und (vor allem!) lustige Plattform-Herausforderungen erstellen können, um den Fall-Guys-Kurs deiner Träume zu erstellen.

Erstellen von Animationen, die sich bewegen, drehen und skalieren

Befolge diese Schritte, um alles zusammenzubringen:

1. Erstelle mithilfe des Verse Explorer eine neue Verse-Klasse namens animating_prop, die von movable_prop erbt. Füge den Bezeichner <concrete> zu dieser Klasse hinzu, um ihre Eigenschaften in UEFN freizugeben.

   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. Füge die Anweisungen using { /Fortnite.com/Devices/CreativeAnimation } und using { /UnrealEngine.com/Temporary/SpatialMath } oben in der Datei hinzu, um diese Module zu importieren. Du benötigst diese, um dein Prop zu animieren. Die in diesem Abschnitt verwendeten Tooltipps sind hier ebenfalls enthalten.

   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. Füge oben in der Klassendefinition von animating_prop die folgenden Felder hinzu:

   1. Ein editable rotation mit dem Namen AdditionalRotation. Dies ist die Drehung, die pro Keyframe auf das RootProp angewendet werden soll.

      Verse

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

      Copy full snippet(3 lines long)

   2. Ein editable float mit dem Namen RotationRate. Dies ist die Zeit in Sekunden, die für eine AdditionalRotation erforderlich ist.

      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. Ein editable logic mit dem Namen UseEasePerKeyFrame. Dies gibt vor, ob jeder Keyframe den MoveEaseType für die Interpolation verwendet. Wenn dies in diesem Beispiel auf False festgelegt wird, wird standardmäßig der lineare Interpolationstyp für jeden Frame verwendet.

      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. Ein editable array von creative_prop mit dem Namen MoveTargets. Dies sind die verschiedenen Kreativmodus-Props, zu denen sich dein Stamm-Prop bewegt.

      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. Eine Variable transform mit dem Namen TargetTransform. Dies ist die Transformation, zu der sich dein Stamm-Prop aktuell bewegt.

      Verse

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

      Copy full snippet(2 lines long)

4. Deine Klassendefinition sollte folgendermaßen aussehen:

   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. Überschreibe die Funktion Move() in deiner Klasse animating_prop. Iteriere dann in einem for-Ausdruck durch jedes MoveTarget im Array MoveTargets. Überprüfe, ob jedes MoveTarget gültig ist, und wenn ja, lege TargetTransform auf die Transformation des MoveTarget fest.

   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. Füge in der Datei movement_behaviors eine neue Methode mit dem Namen BuildMovingAnimationKeyframes() hinzu. Diese Funktion erstellt ein Array mit Keyframes und gibt es zurück, das ein Prop animiert, das sich zu einer Zieltransformation bewegt und dreht. Diese Funktion erwartet mehrere Parameter von animating_prop – MoveDuration, RotationRate, AdditionalRotation, OriginalTransform (die Starttransformation des Prop), TargetTransform, MoveEaseType, und einen neuen logic-Wert mit dem Namen UseEasePerKeyframe. Dies bestimmt, ob du MoveEaseType für jeden Keyframe verwendest. Deine Funktionssignatur sollte wie folgt aussehen:

   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. Initialisiere in BuildMovingAnimationKeyframes() die folgenden Variablen:

   1. Ein Variablen-Array von keyframe_delta mit dem Namen Keyframes. Dies ist das Array, das du am Ende zurückgibst.

      Verse

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

      Copy full snippet(2 lines long)

   2. Eine float-Variable mit dem Namen TotalTime. Dies ist die Gesamtzeit, die bisher für die Animation angefallen ist.

      Verse

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

      Copy full snippet(2 lines long)

   3. Zwei transform-Variablen mit den Namen StartTransform und EndTransform. Dies sind die Start- und Endtransformationen des Prop zu Beginn und am Ende jedes Keyframe. Initialisiere beide mit 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. Eine Variable rotation mit dem Namen RotationToApply, initialisiert mit AdditionalRotation. Dies ist die tatsächliche Rotation, die du für jeden Keyframe auf das Prop anwendest. Normalerweise ist dies AdditionalRotation, aber wenn du eine Teildrehung durchführen musst, änderst du diesen Wert.

      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. Eine float-Variable mit dem Namen AnimationTime. Dies ist die Zeit in Sekunden, die jeder Keyframe benötigt. Initialisiere diese mit 1.0 / RotationRate, da der RootProp eine RotationRate-Anzahl von Drehungen pro Sekunde ausführen muss.

      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. Einen float-Wert mit dem Namen TotalRotations. Dies ist die Gesamtzahl der Drehungen, die während der gesamten Animation ausgeführt werden sollen, und wird mit MoveDuration * RotationRate initialisiert. Dies ist ein float und kein int, weil wir Situationen verarbeiten müssen, in denen keine vollständige Drehung erforderlich ist, wie zum Beispiel am Ende einer Animation.

      Verse

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

      Copy full snippet(2 lines long)

   7. Ein float-Wert mit dem Namen TimePerRotation. Dies ist die Zeit in Sekunden, die für den Abschluss einer Drehung erforderlich ist. Deine Funktion sollte nun wie folgt aussehen.

      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)

Das sind viele Werte, die wir im Auge behalten müssen. Erstellen wir also eine Beispielrechnung mit 2.5 als RotationRate und 5.0 als 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 = 

Mit einer RotationRate von 2.5 und einer MoveDuration von 5.0 führst du insgesamt 12,5 Drehungen aus, wobei jede Drehung 0,4 Sekunden dauert. Das bedeutet, dass du am Ende der Animation eine zusätzliche halbe Drehung ausführen musst. Möglicherweise fällt dir auf, dass die Animationszeit und die Zeit pro Drehung identisch sind. Das ist fast immer der Fall, außer wenn weniger als eine vollständige Drehung erforderlich ist. Auch wenn sie anfangs dem gleichen Wert entsprechen, musst du beide Variablen verfolgen, um später entsprechende Mathematik anzuwenden.

Erstellen von Keyframes in einer Schleife

Zeit, endlich loszulegen! Folge den folgenden Schritten, um die Schleife einzurichten, die deine Keyframes erstellt.

1. Füge einen loop-Ausdruck zu BuildMovingAnimationKeyframes() hinzu. Bei jeder Iteration über der Schleife erstellst du einen neuen Keyframe und fügst ihn zum Keyframes-Array hinzu. Aktualisiere am Anfang der Schleife die TotalTime mit 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. Erstelle EndTransform, wo die Props am Ende dieses Keyframes sein sollen. Lege EndTransform auf eine neue Transformation mit den folgenden Parametern fest:

   1. Lege Translation auf das Ergebnis des Aufrufs von Lerp() zwischen OriginalTransform und TargetTransform fest. Die Funktion Lerp() nimmt zwei Werte und ein lineares Interpolationsverhältnis zwischen 0.0 und 1.0 an. Dann generiert sie basierend auf dem linearen Interpolationsverhältnis einen neuen Wert zwischen den beiden. Je näher das lineare Interpolationsverhältnis bei 1.0 liegt, desto näher befindet sich die Transformation an TargetTransform und umgekehrt.

      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. Lege Rotation auf das Ergebnis von MakeShortestRotationBetween() fest, indem du die Drehung der ursprünglichen Transformation und die ursprüngliche Transformation, die um RotationToApply gedreht wurde, übergibst.

      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. Lege Scale auf das Ergebnis des Aufrufs von Lerp() zwischen OriginalTransform.Scale und TargetTransform.Scale fest. Berücksichtige, dass dies die Skalierung ist, auf die das Prop skalieren soll, nicht der Betrag, um den es skaliert werden muss. Dein fertiges EndTransform sollte wie folgt aussehen:

      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. Nachdem deine Endtransformation festgelegt ist, kannst du einen Keyframe erstellen. Dies ist größtenteils der gleiche Prozess wie bei deiner Funktion MoveToEase(). Erstelle eine neue keyframe_delta-Variable mit dem Namen KeyFrame. Lege DeltaLocation auf die Differenz zwischen der End- und Start-Transformationsverschiebung fest. Lege DeltaRotation auf die Drehung der Endtransformation fest. Da du die Änderung der Skalierung berechnen musst, legst du DeltaScale auf das Ergebnis der Division der Skalierung der Endtransformation durch die Skalierung der Starttransformation fest. Time sollte AnimationTime sein und InterpolationType sollte das Ergebnis eines if-Ausdrucks sein. Wenn UseEasePerKeyframe True ist, verwende MoveEaseType. Verwende andernfalls den linearen Typ. Dein Keyframe-Ausdruck sollte wie folgt aussehen:

   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. Da du deinen Keyframe erstellt hast, kannst du ihn nun zum Keyframes-Array hinzufügen. Lege dann StartTransform auf EndTransform fest, um es für den nächsten Keyframe zu aktualisieren. Wenn TotalTime nun größer als MoveDuration ist, verlasse die Schleife.

   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. Es ist ein wichtiger Sonderfall zu berücksichtigen: Was passiert, wenn du weniger als eine volle Umdrehung ausführen musst? Da du TimePerRotation zu TotalTime hinzufügst, bedeutet dies, dass TotalTime zu Beginn der Schleife höher als MoveDuration sein kann. In dieser Situation musst du die verbleibende Zeit verarbeiten und keine vollständige Drehung machen sowie eine kürzere Animationszeit verwenden, um die Differenz zu berücksichtigen. Befolge diese Schritte, um diese Situation zu berücksichtigen:

   1. Starte am Anfang der Schleife nach der Aktualisierung von TotalTime einen if-Ausdruck. Initialisiere darin die Variable LeftoverTime und lege sie gleich dem Ergebnis der Subtraktion von TotalTime und MoveDuration fest und prüfe, ob sie größer als 0.0 ist. Dieser Ausdruck weist LeftoverTime nur dann zu, wenn der Vergleich True ist.

      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. Um zu wissen, welche Teildrehung du machen musst, initialisiere eine neue Variable RotationFraction, und lege sie gleich auf die Differenz zwischen TimePerRotation und LeftoverTime fest, alle geteilt durch 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. Um eine veränderte Drehung aus RotationFraction zu erstellen, verwendest du Slerp[]. Dies ist die Version von Lerp(), die eine sphärische Interpolation verarbeitet und ähnliche Parameter hat. Sie findet die kürzestes Drehung zwischen zwei verschiedenen Drehungen und gibt eine Drehung auf der Basis des Lerp-Parameters zurück. Rufe Slerp[] auf, interpoliere zwischen IdentityRotation() und IdentityRotation() gedreht um RotationToApply und verwende RotationFraction als linearen Interpolationsparameter. Du verwendest hier IdentityRotation(), weil du nur herausfinden möchtest, welche Teildrehung du anwenden musst, nicht an welcher endgültigen Drehung sich EndTransform befinden sollte.

      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. Nachdem diese Werte festgelegt sind, legst du RotationToApply auf ModifiedRotation fest, multiplizierst AnimationTime mit RotationFraction, um zu wissen, um wie viel du deine Animation kürzen musst, und lege schließlich TotalTime auf MoveDuration fest, da du nicht möchtest, dass es höher als das ist, wenn du EndTransform berechnest.

      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. Ganz am Ende deiner Funktion, nach der Schleife, gibst du das Keyframes-Array zurück. Deine vollständige BuildMovingAnimationKeyframes()-Funktion sollte wie folgt aussehen:

   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. Nachdem du nun die Logik zum Erstellen deiner Keyframes definiert hast, ist es an der Zeit, sie zu animieren. Du wirst eine separate Funktion verwenden, um deine Animation zu erstellen und aufzurufen. Füge eine neue Funktion BuildAndPlayAnimation() zu deiner Klasse animating_prop hinzu. Füge den Modifikator <suspends> zu dieser Funktion hinzu, um ihr zu erlauben, andere asynchrone Funktionen aufzurufen.

   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. Initialisiere in BuildAndPlayAnimation() ein neues Keyframe_Delta-Array mit dem Namen Keyframes. Lege Keyframes dann auf das Ergebnis des Aufrufs von BuildMovingAnimationKeyframes() fest. Verwende RootProp.GetTransform() als anfängliche Transformation, da sich die Position der Props zwischen den Move()-Aufrufen ändern wird. Initialisiere eine animation_mode-Variable mit animation_mode.OneShot und rufe MoveToEase() auf. Übergib das Keyframes-Array und den AnimationMode.

   Deine komplette BuildAndPlayAnimation()-Funktion sollte wie folgt aussehen:

   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. Zurück in Move(), rufe BuildAndPlayAnimation() auf, nachdem du TargetTransform auf die Transformation zum Ziel hierhin festgelegt hast.

   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)

Es gibt einen weiteren Fall, den wir berücksichtigen müssen. Was soll passieren, wenn wir keine Bewegungsziele festlegen? In dieser Situation soll sich dein Prop weiter an seiner Position drehen, ohne sich zu einem neuen Ziel zu bewegen. Um dies zu verarbeiten, füge einen if-Ausdruck am Anfang deiner Move()-Funktion hinzu. Prüfe im if-Ausdruck, ob MoveTargets.Length = 0 ist und lege TargetTransform auf die Transformation des Stamm-Props fest, wenn dies der Fall ist. Rufe dann BuildAndPlayAnimation() auf. Auf diese Art wird dein Prop weiterhin animiert, auch wenn du kein Bewegungsziel festgelegt hast. Deine komplette Move()-Animation sollte wie folgt aussehen:

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

Jetzt musst du animating_prop in deiner Klasse prop_animator Klasse referenzieren. Füge in prop_animator ein bearbeitbares Array von animating_prop mit dem Namen MoveAndRotateProps hinzu. Initialisiere in OnBegin() in einem weiteren for-Ausdruck jedes Prop in MoveAndRotateProps, indem du Setup() aufrufst. Deine komplette Klasse prop_animator sollte wie folgt aussehen:

    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.

Speichere deinen Code und kompiliere ihn.

Herzlichen Glückwunsch, damit haben wir den gesamten Code abgehakt. Jetzt ist es an der Zeit, alles miteinander zu verbinden.

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

Verbinden von Props mit Geräten

Lösche zurück im Editor einen Abschnitt des Kurses nach dem Abschnitt zum Drehen der Props, um eine Lücke vor dem Endziel zu erzeugen. Füge deinem Level einen weiteren FG01 SpinningBar Double S und FG01 Hover Platform M hinzu. Benenne sie SpinningMovingBar und TranslatingPlatform und füge dann mehrere FG01 Button Bulb Props hinzu, die die Ziele sind, zu denen sich jedes Prop bewegen wird. Benenne diese PlatformTarget. Platziere die Plattformen und den Balken über der Lücke und stelle sicher, dass du die Ziele dort platzierst, wohin sich die Plattformen bewegen sollen. In diesem Beispiel bewegt sich der drehende Balken seitwärts, während die Plattform sich vor und zurück bewegt.

Einrichtung des Drehbalkens und der beweglichen Plattform. Die Pfeile zeigen, in welche Richtungen sich das jeweilige Prop bewegt. Sowohl der Drehbalken als auch die Plattform bewegen sich vor und zurück, und der Drehbalken dreht sich bei der Bewegung.

Wähle deinen Prop-Animator im Outliner aus. Füge ein Array-Element zu AnimatingProps für deinen sich Drehbalken hinzu. Lege jeden Wert wie folgt fest:

Füge für deine sich bewegende Plattform ein weiteres Array-Element zu TranslatingProps hinzu. Weise MoveTargets deinen Plattformzielen und RootProp der TranslatingPlatform zu.

Klicke auf Sitzung starten und versuche, deinen kompletten Hindernisparcours zu absolvieren!

Du bist am Zug

Und das war‘s schon! Du hast jetzt alles, was du benötigst, um deinen eigenen Fall-Guys-Hindernisparcours mit Verse zu erstellen.

Du kannst mit dem Code hier Kreativmodus-Props in jedem deiner Erlebnisse animieren und sogar über Fall-Guys-Projekte hinausgehen.

Probiere mit dem, was du gelernt hast, Folgendes aus:

• Erstelle Hindernisse, die sich in verschiedene Richtungen drehen oder sich zufällig über Keyframes drehen.

• Erstelle Hindernisse, die nur aktiviert werden, wenn ein Spieler darauf steht oder sich ihnen auf einen bestimmten Abstand nähert.

• Überlege dir, wie du Plattformen erstellen kannst, die nach einer bestimmten Dauer verschwinden, oder wie du Spieler in gefährliche Positionen bewegst, wenn sie zu lange bleiben.

Vollständiger Code

Dies ist der vollständige Code, der in dieser Sektion erstellt wurde, einschließlich einer Beispiel-Umgestaltung für 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 (Beispiel-Umgestaltung von 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."