6. Combiner le mouvement, la rotation et le changement d'échelle

L'étape suivante, après les objets qui se déplacent, tournent ou changent d'échelle, consiste à leur faire faire les trois simultanément. Cependant, il y a des défis importants à relever lors de la création d'animations pour des accessoires qui se déplacent de plusieurs façons en même temps.

Étant donné que le contrôleur d'animation ne peut jouer qu'une seule animation à la fois, il n'est pas possible d'effectuer des déplacements, des rotations et des mises à l'échelle dans des animations distinctes. Ces animations nécessitent également plusieurs images clés, car il se peut que vous souhaitiez faire pivoter un accessoire plusieurs fois par animation. Étant donné que vous devez créer toutes les images clés à l'avance, vous devez également calculer la position, la rotation et l'échelle à chaque point du parcours de l'accessoire. Que se passe-t-il si votre accessoire n'effectue pas un nombre égal de rotations ? Comment gérer une demi-rotation ?

Cette section implique de nombreux calculs, mais à la fin, vous serez en mesure de déplacer, de faire pivoter et de changer l'échelle des accessoires en plusieurs points, et de créer des objets complexes, dynamiques et (le plus important !) des défis de plateforme amusants pour créer la course Fall Guys de vos rêves.

Créer des animations qui se déplacent, tournent et changent d'échelle

Procédez comme suit pour commencer à rassembler les éléments :

1. Créez une nouvelle classe Verse nommée animating_prop qui hérite de movable_prop à l'aide de l'explorateur Verse. Ajoutez le spécificateur <concrete> à cette classe pour exposer ses propriétés à l'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. Ajoutez les instructions using { /Fortnite.com/Devices/CreativeAnimation } et using { /UnrealEngine.com/Temporary/SpatialMath } en haut du fichier pour importer ces modules. Vous en aurez besoin pour animer votre accessoire. Les infobulles utilisées dans cette section sont également répertoriées ici.

   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. Ajoutez les champs suivants en haut de la définition de la classe animating_prop :

   1. Une rotation modifiable nommée AdditionalRotation. Il s'agit de la rotation à appliquer au RootProp par image clé.

      Verse

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

      Copy full snippet(3 lines long)

   2. Un float modifiable nommé RotationRate. Il s'agit du temps qu'il faut pour effectuer une AdditionalRotation, en secondes.

      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. Une logic modifiable nommée UseEasePerKeyFrame. Elle détermine si chaque image clé utilise le MoveEaseType pour l'interpolation. Dans cet exemple, la valeur false permet d'utiliser par défaut le type d'interpolation linéaire pour chaque image.

      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. Une matrice modifiable de creative_prop nommée MoveTargets. Il s'agit des différents accessoires en mode Créatif vers lesquels votre accessoire racine se déplacera.

      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. Une variable transform de variable nommée TargetTransform. Il s'agit de la transformation vers laquelle votre accessoire racine se déplace actuellement.

      Verse

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

      Copy full snippet(2 lines long)

4. La définition de votre classe devrait ressembler à ceci :

   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. Remplacez la fonction Move() dans votre classe animating_prop. Ensuite, dans une expression for, itérez à chaque MoveTarget de la matrice MoveTargets. Vérifiez si chaque MoveTarget est valide, et si tel est le cas, définissez la TargetTransform sur la transformation de la 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. Dans votre fichier movement_behaviors, ajoutez une nouvelle méthode nommée BuildMovingAnimationKeyframes(). Cette fonction crée et renvoie une matrice d'images clés qui animent le déplacement et la rotation d'un accessoire en fonction d'une transformation cible. Cette fonction prend plusieurs paramètres d'animating_prop, notamment MoveDuration, RotationRate, AdditionalRotation, OriginalTransform (la transformation de départ de l'accessoire), TargetTransform, MoveEaseType et une nouvelle valeur logic appelée UseEasePerKeyframe. Cela détermine si l'on utilise le MoveEaseType pour chaque image clé. La signature de votre fonction doit ressembler à ceci :

   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. Dans BuildMovingAnimationKeyframes(), initialisez les variables suivantes :

   1. Une matrice variable de keyframe_delta nommée Keyframes. Il s'agit de la matrice que vous renverrez à la fin.

      Verse

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

      Copy full snippet(2 lines long)

   2. Une variable float nommée TotalTime. Il s'agit du temps total consacré à l'animation jusqu'à présent.

      Verse

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

      Copy full snippet(2 lines long)

   3. Deux variables transform nommées StartTransform et EndTransform. Il s'agit des transformations de départ et de fin de l'accessoire au début et à la fin de chaque image clé. Initialisez les deux à l'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. Une variable rotation nommée RotationToApply, initialisée à l'AdditionalRotation. Il s'agit de la rotation réelle que vous appliquerez à l'accessoire pour chaque image clé. En général, il s'agit de l'AdditionalRotation, mais si vous avez besoin d'effectuer une rotation fractionnaire, vous devez changer cette valeur.

      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. Une variable float nommée AnimationTime. Il s'agit de la durée en secondes de chaque image clé. Initialisez cette valeur sur 1.0 / RotationRate, puisque le RootProp doit effectuer un nombre de RotationRate rotations par seconde.

      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. Une valeur float nommée TotalRotations. Il s'agit du nombre total de rotations à effectuer sur l'ensemble de l'animation, et il est initialisé à MoveDuration * RotationRate. La raison pour laquelle il s'agit d'un float et non d'un int est que cela permet de gérer les situations où il n'est pas nécessaire d'effectuer une rotation complète, comme à la fin d'une animation.

      Verse

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

      Copy full snippet(2 lines long)

   7. Une valeur float nommée TimePerRotation. Il s'agit du temps en secondes nécessaire pour effectuer une rotation. Votre fonction devrait maintenant ressembler à ceci.

      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)

Cela représente un grand nombre de valeurs à prendre en compte. Faisons donc un exemple de calcul, en utilisant 2.5 comme RotationRate et 5.0 comme 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 = 

Avec un RotationRate de 2,5 et une MoveDuration de 5,0, vous effectuerez 12,5 rotations au total, chaque rotation prenant 0,4 seconde. Cela signifie que vous devrez effectuer une demi-rotation supplémentaire à la fin de l'animation. Vous remarquerez également que la durée de l'animation et le temps par rotation sont identiques. C'est presque toujours le cas, sauf lorsque l'on doit effectuer moins d'une rotation complète. Même si elles ont initialement la même valeur, vous devrez garder une trace des deux variables pour effectuer des calculs ultérieurs.

Créer des images clés dans une boucle

Il est temps de passer à l'action ! Procédez comme suit pour configurer la boucle de création de vos images clés.

1. Ajoutez une expression loop à BuildMovingAnimationKeyframes(). À chaque itération de la boucle, vous créerez une nouvelle image clé et l'ajouterez à la matrice des images clés. Au début de la boucle, mettez à jour la TotalTime avec le 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. Créez l'EndTransform, qui est l'endroit où l'accessoire doit se trouver à la fin de cette image clé. Définissez l'EndTransform sur une nouvelle transformation avec les paramètres suivants :

   1. Définissez la Translation sur le résultat de l'appel de Lerp() entre l'OriginalTransform et la TargetTransform. La fonction Lerp() prend deux valeurs et un rapport de Lerp compris entre 0,0 et 1,0. Elle génère ensuite une nouvelle valeur située entre les deux, sur la base du rapport de Lerp. Plus le rapport de Lerp est proche de 1.0, plus la transformation sera proche de TargetTransform, et inversement.

      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. Définissez la Rotation sur le résultat de MakeShortestRotationBetween(), en transmettant la rotation de la transformation d'origine et la transformation d'origine pivotée de 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. Définissez l'échelle sur le résultat de l'appel de Lerp() entre l'OriginalTransform.Scale et la TargetTransform.Scale. Gardez à l'esprit qu'il s'agit de l'échelle à appliquer à l'accessoire, et non de la valeur de changement d'échelle. Votre EndTransform complète doit ressembler à ceci :

      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. Une fois la transformation finale définie, il est temps de créer une image clé ! Il s'agit en grande partie du même processus que vous avez suivi pour votre fonction MoveToEase(). Créez une nouvelle variable keyframe_delta nommée KeyFrame. Définissez la valeur de DeltaLocation sur la différence entre les déplacements de transformation de fin et de début. Définissez la DeltaRotation sur la rotation de la transformation finale. Puisque vous devez calculer le changement d'échelle, définissez la DeltaScale sur le résultat de la division de l'échelle de la transformation de fin par celle de la transformation de départ. La durée Time doit être la durée d'AnimationTime, et InterpolationType doit être le résultat d'une expression if. Si UseEasePerKeyframe est activé, utilisez le MoveEaseType. Dans le cas contraire, utiliser le type linéaire. Votre expression d'image clé devrait ressembler à ceci :

   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. Une fois votre image clé créée, vous pouvez maintenant l'ajouter à la matriceKeyframes. Définissez ensuite la StartTransform sur l'EndTransform afin de la mettre à jour pour l'image clé suivante. Enfin, si la TotalTime est maintenant supérieure à la MoveDuration, la boucle s'arrête.

   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. Il existe un cas dont il faut tenir compte : que se passe-t-il lorsque l'on a besoin d'effectuer moins d'une rotation complète ? Étant donné qu'on ajoute le TimePerRotation à la TotalTime, cela signifie que la TotalTimepourrait être plus élevée que la MoveDuration au début de la boucle. Dans cette situation, vous devez gérer le temps restant et effectuer une rotation inférieure à la rotation complète, avec un temps d'animation plus court pour tenir compte de la différence. Procédez comme suit pour tenir compte de cette situation :

   1. Au début de la boucle, après avoir mis à jour TotalTime, lancez une expression if. À l'intérieur, initialisez une variable LeftoverTime et rendez-la égale au résultat de la soustraction de TotalTime et MoveDuration, en vérifiant si elle est supérieure à 0,0. Cette expression n'attribuera LeftoverTime que si la comparaison est activée.

      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. Pour savoir quelle fraction de rotation vous devez effectuer, initialisez une nouvelle variable Rotation Fraction, et définissez-la sur la différence entre le TimePerRotation et le LeftoverTime, le tout divisé par le 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. Pour créer une rotation modifiée à partir de la RotationFraction, vous utiliserez Slerp[]. Il s'agit de la version de Lerp() qui gère l'interpolation sphérique et qui a des paramètres similaires. Elle recherche la rotation la plus courte entre deux rotations différentes et renvoie une rotation en fonction du paramètre du lerp. Appelez Slerp[], en interpolant entre l'IdentityRotation() et l'IdentityRotation() pivoté en fonction de RotationToApply, en utilisant la RotationFraction comme paramètre de lerp. Nous utilisons IdentityRotation() ici parce que seule la rotation fractionnaire que nous devons appliquer nous intéresse, et non pas la rotation finale de l'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. Une fois ces valeurs définies, définissez la RotationToApply sur la ModifiedRotation, multipliez l'AnimationTime par la RotationFraction pour savoir de combien raccourcir votre animation, et définissez enfin la TotalTime sur la MoveDuration puisqu'elle n'est pas censée la dépasser lors du calcul de l'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. À la toute fin de votre fonction, après la boucle, renvoyez la matrice Keyframes. Votre fonction BuildMovingAnimationKeyframes() complète devrait ressembler à ceci :

   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. Maintenant que vous avez défini la logique de création de vos images clés, il est temps de les animer. Vous utiliserez une fonction distincte pour créer et appeler votre animation. Ajoutez une nouvelle fonction BuildAndPlayAnimation() à votre classe animating_prop. Ajoutez le modificateur <suspends> à cette fonction pour lui permettre d'appeler d'autres fonctions asynchrones.

   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. Dans BuildAndPlayAnimation(), initialisez une nouvelle matrice keyframe_delta nommée Keyframes. Ensuite, définissez Keyframes sur le résultat de l'appel de BuildMovingAnimationKeyframes(). Utilisez RootProp.GetTransform() comme transformation de départ puisque la position de l'accessoire changera entre les appels de Move(). Initialisez une variable animation_mode sur animation_mode.OneShot et appelez MoveToEase() en transmettant la matrice Keyframes et l'AnimationMode.

   Votre fonction BuildAndPlayAnimation() complète devrait ressembler à ceci :

   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. De retour dans Move(), appelez BuildAndPlayAnimation() après avoir défini la TargetTransform sur la transformation des cibles du déplacement.

   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)

Il existe un autre cas à prendre en considération. Que se passe-t-il si l'on ne définit pas de cibles de déplacement ? Dans ce cas, l'accessoire doit continuer à tourner sur place, sans changer de destination. Pour gérer cela, ajoutez une expression if au début de votre fonction Move(). Dans l'expression if, vérifiez si MoveTargets.Length = 0, et si tel est le cas, définissez la TargetTransform sur la transformation de l'accessoire racine. Ensuite, appelez BuildAndPlayAnimation(). De cette façon, votre accessoire continuera à s'animer même si vous n'avez pas défini de cible de déplacement. Votre animation Move() complète devrait ressembler à ceci :

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

Vous devez maintenant référencer animating_prop dans votre classe prop_animator. Dans prop_animator, ajoutez une matrice modifiable d'animating_prop nommée MoveAndRotateProps. Dans une autre expression for dans OnBegin(), initialisez chaque accessoire de MoveAndRotateProps en appelant Setup(). Votre classe prop_animator complète devrait ressembler à ceci :

    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.

Enregistrez votre code et compilez-le.

Félicitations, le code est maintenant terminé ! Il est maintenant temps de tout relier.

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

Lier des accessoires aux appareils

De retour dans l'éditeur, supprimez une section de la course après la section des accessoires rotatifs afin de créer un espace vide avant l'objectif final. Ajoutez une autre FG01 Barre rotative double S et une FG01 Plaque de lévitation M à votre niveau. Nommez-les SpinningMovingBar et TranslatingPlatform, puis ajoutez plusieurs accessoires FG01 Bouton ampoule, qui seront les cibles vers lesquelles chaque accessoire se déplacera. Nommez-les PlatformTarget. Placez les plateformes et la barre au-dessus de l'espace vide, et assurez-vous de placer les cibles là où vous voulez que les plateformes se déplacent. Dans cet exemple, la barre tournante se déplace d'un côté à l'autre, tandis que la plateforme se déplace d'avant en arrière.

Configurer la barre tournante et la plateforme mobile. Les flèches indiquent la direction dans laquelle chaque accessoire se déplace. La barre tournante et la plateforme se déplacent d'avant en arrière, et la barre tournante tourne en même temps qu'elle se déplace.

Sélectionnez votre animateur d'accessoire dans l'organiseur. Ajoutez un élément de matrice à AnimatingProps pour votre barre tournante. Définissez chaque valeur comme suit :

Ajoutez un autre élément de matrice à TranslatingProps pour votre plateforme mobile. Assignez les MoveTargets aux cibles de votre plateforme, et le RootProp à votre TranslatingPlatform.

Appuyez sur Lancer la session et essayez de traverser votre course d'obstacles jusqu'au bout !

À vous de jouer

Vous avez terminé ! Vous avez maintenant en main tous les outils nécessaires pour créer votre propre course d'obstacles Fall Guys à l'aide de Verse !

Vous pouvez utiliser le code indiqué ici pour animer des accessoires en mode Créatif dans n'importe laquelle de vos expériences, et même au-delà des projets Fall Guys !

Utilisez vos connaissances pour vous essayer aux défis suivants :

• Créez des obstacles qui tournent dans différentes directions ou qui tournent de manière aléatoire entre les images clés.

• Créez des obstacles qui ne s'activent que lorsqu'un joueur se trouve au-dessus ou à une certaine distance.

• Trouvez comment créer des plateformes qui disparaissent au bout d'un certain temps ou déplacez le joueur à des endroits dangereux s'il reste trop longtemps sur une plateforme.

Code complet

Voici le code complet créé dans cette section, y compris un exemple de refactorisation d'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):

rotation_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 (exemple de refactorisation d'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."