6. Cómo combinar movimiento, rotación y escala

La etapa siguiente a los objetos que se mueven, rotan o escalan es hacer las tres cosas a la vez. No obstante, a la hora de crear animaciones para elementos que se mueven de varias maneras al mismo tiempo, hay que tener en cuenta algunos problemas importantes.

Como el controlador de animación solo puede reproducir una animación a la vez, no puedes hacer el movimiento, la rotación y la escala en animaciones separadas. Estas animaciones también necesitan múltiples fotogramas clave, ya que es posible que quieras rotar un elemento varias veces por animación. Como tienes que construir todos los fotogramas clave con antelación, también tienes que calcular la posición, la rotación y la escala en cada punto del recorrido del elemento. ¿Qué ocurre si el elemento no realiza el mismo número de rotaciones? ¿Cómo se puede gestionar media rotación?

En esta sección habrá un montón de matemáticas, pero al final serás capaz de mover, rotar y escalar elementos a múltiples puntos, y crear elementos complejos, dinámicos y (¡lo más importante!) divertidos desafíos de plataformas para hacer el recorrido de Fall Guys de tus sueños.

Cómo crear animaciones con movimiento, rotación y escala

Sigue los pasos que se indican a continuación para empezar a poner todo en orden:

1. Crea una nueva clase de Verse con el nombre animating_prop que herede de movable_prop mediante el explorador de Verse. Añade el especificador <concrete> a esta clase para exponer sus propiedades a 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. Añade las declaraciones using { /Fortnite.com/Devices/CreativeAnimation } y using { /UnrealEngine.com/Temporary/SpatialMath } en la parte superior del archivo para importar estos módulos. Necesitarás estos módulos para animar el elemento. También se incluyen aquí los consejos utilizados en esta sección.

   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. En la parte superior de la definición de la clase animating_prop, añade los siguientes campos:

   1. Una rotation editable con el nombre AdditionalRotation. Esta es la rotación que se aplicará al RootProp por fotograma clave.

      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 editable con el nombre RotationRate. Esta es la cantidad de tiempo que se tarda en realizar una AdditionalRotation, en segundos.

      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. Una logic editable con el nombre UseEasePerKeyFrame. Esto determina si cada fotograma clave utiliza el MoveEaseType para la interpolación. En este ejemplo, al establecer este valor en false, se utilizará de forma predeterminada el tipo de interpolación lineal para cada fotograma.

      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. Una matriz editable de creative_prop con el nombre MoveTargets. Estos son los diferentes elementos del modo Creativo a los que se desplazará tu elemento raíz.

      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. Una variable transform con el nombre TargetTransform. Esta es la transformación a la que se desplaza actualmente tu elemento raíz.

      Verse

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

      Copy full snippet(2 lines long)

4. La definición de la clase debería tener este aspecto:

   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. Anula la función Move() en tu clase animating_prop. Después, en una expresión for, itera cada MoveTarget de la matriz MoveTargets. Comprueba si cada MoveTarget es válido y, en caso afirmativo, establece la TargetTransform en la transformación del 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. En el archivo movement_behaviors, añade un nuevo método con el nombre BuildMovingAnimationKeyframes(). Esta función construirá y devolverá una matriz de fotogramas clave que animan un elemento que se mueve y rota hacia una transformación objetivo. Esta función recibe varios parámetros de animating_prop: MoveDuration, RotationRate, AdditionalRotation, OriginalTransform (la transformación inicial del elemento), TargetTransform, MoveEaseType y un nuevo valor logic con el nombre UseEasePerKeyframe. Esto determina si se utiliza el MoveEaseType para cada fotograma clave. La firma de la función debería tener el siguiente aspecto:

   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. En BuildMovingAnimationKeyframes(), inicializa las siguientes variables:

   1. Una matriz variable de keyframe_delta denominada Keyframes. Esta es la matriz que devolverás al final.

      Verse

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

      Copy full snippet(2 lines long)

   2. Una variable float con el nombre TotalTime. Esta es la cantidad total de tiempo invertido en la animación hasta el momento.

      Verse

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

      Copy full snippet(2 lines long)

   3. Dos variables transform con los nombres StartTransform y EndTransform. Estas son las transformaciones iniciales y finales del elemento al inicio y al final de cada fotograma clave. Inicializa las dos a 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. Una variable rotation con el nombre RotationToApply, inicializada con el valor AdditionalRotation. Esta es la rotación actual que se aplicará al elemento para cada fotograma clave. Por lo general, será la AdditionalRotation, pero si necesitas hacer una rotación fraccional tendrás que cambiar este valor.

      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. Una variable float con el nombre AnimationTime. Esta es la cantidad de tiempo en segundos que tarda cada fotograma clave. Inicializa este valor a 1.0 / RotationRate, ya que el RootProp necesita hacer un número de rotaciones RotationRate por segundo.

      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. Un valor float con el nombre TotalRotations. Este es el número total de rotaciones que se van a realizar a lo largo de toda la animación, y se inicializa en MoveDuration * RotationRate. El motivo por el que esto es un float y no un int es para lidiar con situaciones en las que no necesitas hacer una rotación completa, como al final de una animación.

      Verse

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

      Copy full snippet(2 lines long)

   7. Un valor float con el nombre TimePerRotation. Esta es la cantidad de tiempo en segundos que tarda una rotación en completarse. Tu función debería tener ahora el siguiente aspecto.

      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)

Hay muchos valores a tener en cuenta, así que vamos a hacer un cálculo de ejemplo, utilizando 2.5 como RotationRate y 5.0 como 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 = 

Con una RotationRate de 2.5 y una MoveDuration de 5.0, harás 12.5 rotaciones en total, cada una de las cuales tardará 0.4 segundos. Esto quiere decir que tendrás que hacer una media rotación extra al final de la animación. Además, puedes observar que el tiempo de animación y el tiempo por rotación son los mismos. Casi siempre es así, excepto cuando se necesita hacer menos de una rotación completa. Aunque inicialmente tengan el mismo valor, necesitarás tener un registro de ambas variables para poder realizar algunas operaciones matemáticas posteriores.

Cómo crear fotogramas clave en un bucle

¡Ha llegado el momento de empezar a construir! Sigue los pasos que se indican a continuación para configurar el bucle que construye tus fotogramas clave.

1. Añade una expresión loop a BuildMovingAnimationKeyframes(). En cada iteración del bucle, construirás un nuevo fotograma clave y lo añadirás a la matriz de fotogramas clave. Al inicio del bucle, actualiza el TotalTime con el 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. Compila la EndTransform, que es donde debería estar el elemento al final de este fotograma clave. Establece la EndTransform a una nueva transformación con los siguientes parámetros:

   1. Establece la Translation al resultado de llamar a Lerp() entre la OriginalTransform y la TargetTransform. La función Lerp() recibe dos valores y una relación de interpolación lineal entre 0.0 y 1.0. Posteriormente, genera un nuevo valor intermedio basado en la relación de interpolación lineal. Cuanto más se acerque la relación de interpolación lineal a 1.0, más se acercará la transformación a la TargetTransform, y viceversa.

      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. Establece la Rotation al resultado de MakeShortestRotationBetween(), pasando la rotación de la transformación original y la transformación original rotada por la 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. Ajusta la Scale al resultado de llamar a Lerp() entre la OriginalTransform.Scale y la TargetTransform.Scale. Ten en cuenta que esta es la escala a la que debería escalar el elemento, no la cantidad por la que tendría que escalar. Tu EndTransform completo debería tener el siguiente aspecto:

      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. Con la transformación final establecida, ¡es hora de construir un fotograma clave! En gran parte, se trata del mismo proceso que realizaste para la función MoveToEase(). Crea una nueva variable keyframe_delta con el nombre KeyFrame. Establece el valor DeltaLocation como la diferencia entre las traslaciones final e inicial de la transformación. Establece DeltaRotation en la rotación de la transformación final. Como necesitas calcular el cambio de escala, establece el valor DeltaScale como el resultado de dividir la escala de la transformación final por la escala de la transformación inicial. El Time debería ser el AnimationTime, y el InterpolationType debería ser el resultado de una expresión if. Si UseEasePerKeyframe está activado, utiliza MoveEaseType. De lo contrario, utiliza el tipo lineal. Tu expresión de fotogramas clave debería tener el siguiente aspecto:

   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. Con el fotograma clave construido, ahora puedes añadirlo a la matriz Keyframes. Después, establece la StartTransform en EndTransform para actualizarla para el siguiente fotograma clave. Por último, si el TotalTime es ahora mayor que el MoveDuration, sal del bucle.

   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. Existe un caso extremo importante que hay que tener en cuenta: ¿qué ocurre cuando se necesita hacer menos de una rotación completa? Como estás añadiendo el TimePerRotation a TotalTime, esto quiere decir que el TotalTime podría ser mayor que la MoveDuration al inicio del bucle. En este caso, tendrás que gestionar el tiempo que sobra y hacer una rotación inferior a la completa, con un tiempo de animación más corto para compensar la diferencia. Sigue estos pasos para tener en cuenta este caso:

   1. Al principio del bucle, después de actualizar TotalTime, inicia una expresión if. Dentro, inicializa una variable LeftoverTime, y establécela igual al resultado de restar TotalTime y MoveDuration, comprobando si es mayor que 0.0. Esta expresión solo asignará LeftoverTime si la comparación da como resultado 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. Para saber qué fracción de rotación tienes que hacer, inicializa una nueva variable Rotation Fraction y establécela igual al resultado de tomar la diferencia entre TimePerRotation y LeftoverTime, todo dividido por 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. Para crear una rotación modificada a partir de RotationFraction, deberás utilizar Slerp[]. Se trata de la versión de Lerp() que gestiona la interpolación esférica y tiene parámetros similares. Esta función encuentra la rotación más corta entre dos rotaciones diferentes y devuelve una rotación basada en el parámetro de interpolación lineal. Llama a Slerp[], interpolando entre la IdentityRotation() y la IdentityRotation() rotada por RotationToApply, utilizando la RotationFraction como parámetro de interpolación lineal. Aquí estás utilizando IdentityRotation() porque solo te interesa encontrar qué rotación fraccional necesitas aplicar, no en qué rotación final debería estar la 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. Con esos valores configurados, establece la RotationToApply en ModifiedRotation, multiplica el AnimationTime por la RotationFraction para saber cuánto acortar la animación y, finalmente, establece el TotalTime en MoveDuration, ya que no quieres que sea mayor que ese valor cuando calcules la 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. Al final de la función, después del bucle, devuelve la matriz Keyframes. Tu función BuildMovingAnimationKeyframes() completa debería tener el siguiente aspecto:

   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. Ahora que has definido la lógica para construir los fotogramas clave, ha llegado el momento de animarlos. Utilizarás una función separada para construir y llamar a la animación. Añade una nueva función BuildAndPlayAnimation() a tu clase animating_prop. Añade el modificador <suspends> a esta función para que pueda llamar a otras funciones asíncronas.

   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. En BuildAndPlayAnimation(), inicializa una nueva matriz keyframe_delta con el nombre Keyframes. Después, establece Keyframes al resultado de llamar a BuildMovingAnimationKeyframes(). Utiliza RootProp.GetTransform() como transformación inicial, ya que la posición del elemento cambiará entre llamadas a Move(). Inicializa una variable animation_mode a animation_mode.OneShot y llama a MoveToEase(), pasando la matriz Keyframes y AnimationMode.

   Tu función BuildAndPlayAnimation() completa debería tener el siguiente aspecto:

   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. En Move(), llama a BuildAndPlayAnimation() después de establecer TargetTransform en la transformación del objetivo de movimiento.

   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)

Hay que tener en cuenta un caso más. ¿Qué pasa si no estableces ningún objetivo de movimiento? En este caso, el elemento debería seguir girando en su sitio, sin desplazarse a un nuevo destino. Para controlarlo, añade una expresión if en la parte superior de tu función Move(). En el if, comprueba si MoveTargets.Length = 0 y, de ser así, establece TargetTransform a la transformación del elemento raíz. Luego llama a BuildAndPlayAnimation(). De este modo, tu elemento seguirá animándose incluso si no has establecido un objetivo de movimiento. Tu animación Move() completa debería tener el siguiente aspecto:

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

Ahora tienes que hacer referencia a animating_prop en tu clase prop_animator. En prop_animator, añade una matriz editable de animating_prop con el nombre MoveAndRotateProps. En OnBegin(), en otra expresión for, inicializa cada elemento en MoveAndRotateProps llamando a Setup(). Tu clase prop_animator completa debería tener el siguiente aspecto:

    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.

Guarda el código y compílalo.

¡Enhorabuena! ¡Ya tienes todo el código! Ahora ha llegado el momento de conectarlo todo.

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

Cómo vincular elementos a dispositivos

De vuelta en el editor, elimina una sección del recorrido después de la sección de elementos que giran para crear un espacio antes del objetivo final. Añade a tu nivel otra barra giratoria doble (pequeña) FG01 y una plataforma flotante (mediana) FG01. Nómbralas SpinningMovingBar y TranslatingPlatform y después añade varios elementos bombilla de botón FG01, que serán los objetivos a los que se moverá cada elemento. Dales el nombre PlatformTarget. Coloca las plataformas y la barra sobre el espacio y asegúrate de colocar los objetivos donde quieres que vayan las plataformas. En este ejemplo, la barra giratoria se mueve de lado a lado y la plataforma se mueve hacia delante y hacia atrás.

Configuración de la barra giratoria y la plataforma móvil. Las flechas indican en qué direcciones se mueve cada elemento. Tanto la barra giratoria como la plataforma se mueven hacia delante y hacia atrás, y la barra gira mientras se mueve.

Selecciona el animador de tu elemento en el esquematizador. Añade un elemento de matriz a AnimatingProps para tu barra giratoria. Establece cada valor de la siguiente manera:

Añade otro elemento de matriz a TranslatingProps para la plataforma móvil. Asigna MoveTargets a tus objetivos de plataforma, y RootProp a tu TranslatingPlatform.

Pulsa Abrir sesión e intenta recorrer tu carrera de obstáculos completa.

Por tu cuenta

¡Y ya está! Ahora tienes todo lo que necesitas para hacer tu propia carrera de obstáculos de Fall Guys con Verse.

Puedes utilizar el código para animar elementos del modo Creativo en cualquiera de tus experiencias, ¡e incluso más allá de los proyectos de Fall Guys!

Con lo que has aprendido, intenta lo siguiente:

• Crea obstáculos que giren en varias direcciones, o que giren aleatoriamente a lo largo de los fotogramas clave.

• Crea obstáculos que solo se activen cuando un jugador se pare sobre ellos o se acerque a cierta distancia.

• Descubre cómo hacer plataformas que desaparezcan después de cierto tiempo, o que lleven al jugador a posiciones peligrosas si permanece demasiado tiempo en ellas.

Código completo

A continuación encontrarás el código completo creado en esta sección, incluido un ejemplo de refactorización para 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 (ejemplo de refactorización de 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."