2. Przenoszenie jednostek za pomocą animacji

Ruchome platformy są powszechnie stosowane w większości platformówek i wymuszają na graczu wykonywanie precyzyjnych skoków między celami w celu dotarcia do mety.

Rekwizytami w UEFN można poruszać na kilka sposobów. Możesz użyć funkcji, takich jak TeleportTo[] lub MoveTo(), aby bezpośrednio modyfikować przekształcenie, lub skorzystać z innego urządzenia, takiego jak przenośnik rekwizytów, aby poruszać rekwizytem wzdłuż zaprogramowanej ścieżki. Istnieje też inna przydatna opcja, czyli animacje.

W porównaniu z ruchem przekształcenia rekwizytu animacje mają kilka zalet. Animacje zwykle charakteryzują się płynniejszym ruchem niż w przypadku poruszania obiektami za pomocą MoveTo() lub TeleportTo(), ponieważ unikają problemu z opóźnieniem sygnału sieciowego występującego przy wywoływaniu tych funkcji co każde tyknięcie gry.

Ponadto animacje mają bardziej spójne kolizje z graczami i innymi obiektami, a twórca ma większą kontrolę nad tym, gdzie i w jaki sposób obiekt się porusza, w porównaniu z urządzeniem przenośnika rekwizytów. Możesz odtwarzać animacje w pętli lub odtwarzać je do przodu i wstecz przy użyciu trybu ping-pongowego.

Animacje umożliwiają też wybranie typu interpolacji. Typ interpolacji decyduje o typie łagodzenia lub krzywej animacji, według której podąża animacja. Na przykład typ interpolacji liniowej odtwarza animację ze stałą szybkością, natomiast typ łagodzenia na początku rozpoczyna animację powoli i przyspiesza pod jej koniec.

Wybierając dla animacji odpowiedni typ interpolacji, możesz określić konkretne punkty, w których rekwizyt ma zwolnić, przyspieszyć lub poruszać się liniowo. Stosując komponent w celu zaimplementowania tych zachowań do jednostek w poziomie, możesz tworzyć ruchome platformy, po których gracze będą mogli się poruszać.

Najpierw zastanów się, jakie zachowania powinna być w stanie wykonać ruchoma platforma. Animacja powinna rozpoczynać się od określonej pozycji początkowej, a następnie wykonywać przesunięcie do wielu punktów. Po zakończeniu ruchu platforma powinna być w stanie wrócić do pozycji początkowej lub pozostać w miejscu.

Powinien wykonywać te ruchy przez określony czas, mieć możliwość odpowiedniego obracania i skalowania w każdym punkcie swojej drogi. Każde z tych zachowań będzie wymagało określonego kodu, jednak rozpoczęcie od prostej klasy, którą następnie rozbudujesz, pozwala szybko nadawać kształt różnym pomysłom. Wykonaj poniższe kroki, aby utworzyć komponent ruchu oparty na animacji.

1. Utwórz nowy komponent Verse o nazwie animate_to_targets_component i otwórz go w Visual Studio Code. Aby dowiedzieć się więcej na temat tworzenia własnych komponentów Verse, patrz: Tworzenie własnego komponentu Verse. Dodaj polecenie using dla /Verse.org/SpatialMath, /Verse.org/SceneGraph/KeyframedMovement, i /UnrealEngine.com/Temporary/SpatialMath . Funkcje z każdego z nich będą potrzebne później.

   Verse

   using { /Verse.org }
   using { /Verse.org/Native }
   using { /Verse.org/SceneGraph }
   using { /Verse.org/Simulation }
   using { /Verse.org/SpatialMath }
   using { /Verse.org/SceneGraph/KeyframedMovement }
   using { /UnrealEngine.com/Temporary/SpatialMath }
   
   # Place this component to an entity to move between preset targets.
   animate_to_targets_component<public> := class<final_super>(component):

   Copy full snippet(10 lines long)

2. Podpowiedzi do narzędzi wykorzystanych w tej sekcji samouczka zamieszczono poniżej. Można je skopiować i wkleić nad definicją klasy animate_to_targets_component. 

   Verse

   # Editor Tool Tips
   DefaultSpeedTip<localizes><public>:message = "Default speed simulation entity moves during any segment that does not specify a speed."
   SpeedTip<localizes><public>:message = "Speed simulation entity moves during this segment."
   AnimationDurationTip<localizes><public>:message = "The duration of the animation segment in seconds."
   EasingFunctionTip<localizes><public>:message = "Movement cubic-bezier easing function during this segment."
   DefaultEasingFunctionTip<localizes><public>:message = "Default movement cubic-bezier easing function during any segment that does not specify an easing function."
   PlaybackModeTip<localizes><public>:message = "Animation playback mode\n\tOneshot: Animation plays once.\n\tPingPong: Animation plays in order and reverse order repeating.\n\tLoop: Animation repeats in a loop. Tip: To construct an animation in a closed loop, make the last segment starting position the same as the first segment starting position."
   TargetsTip<localizes><public>:message = "Entities that are targets for the parent entity."
   RandomizeTargetsTip<localizes><public>:message = "Randomize the order of the segments.\n\tNever: Always use the order specified.\n\tOnBegin: Only randomize the order on begin simulation.\n\tEveryIteration: Randomize the order of the segments every loop iteration."
   PauseTip<localizes><public>:message = "Duration simulation entity pauses at the beginning of this segment."
   
   Expand code Copy full snippet(16 lines long)

3. Dodaj następujące pola do definicji klasy animate_to_targets_component:

   • Edytowalna zmienna o wartości zmiennopozycyjnej o nazwie InitialPauseSeconds. Jest to ilość czasu do rozpoczęcia animacji jednostki. Ustaw tę wartość na 10.0, aby jednostka odczekała dziesięć sekund, zanim rozpocznie się animacja.

   Verse

   # Amount of time to pause before the animation starts.
   @editable_number(float):
       ToolTip := SpeedTip
       MinValue := option{0.0}
   var InitialPauseSeconds<public>:float = 10.0

   Copy full snippet(5 lines long)

   • Edytowalny obiekt keyframed_movement_playback_mode o nazwie AnimationPlaybackMode. To jest tryb animacji dla animacji jednostki. Ustaw to na loop_keyframed_movement_playback_mode. Oznacza to, że domyślnie, gdy animacja zostanie ukończona, jednostka wykona pętlę i ponownie rozpocznie animację od początku.

   Verse

   # The playback mode used by this animation.
   @editable:
       ToolTip := PlaybackModeTip
   var PlaybackMode<public>:keyframed_movement_playback_mode = loop_keyframed_movement_playback_mode{}

   Copy full snippet(4 lines long)

4. Zapisz kod i go skompiluj.

Dzielenie animacji na segmenty

Aby zbudować animacje w kodzie, użyjesz klatek kluczowych. Animacje tworzy się z jednej lub wielu klatek kluczowych. Każda klatka kluczowa określa wartości obiektu w konkretnych punktach animacji. Tworząc animację przy użyciu klatek kluczowych, możesz określić wiele punktów, do których rekwizyt ma się poruszać, obracać, a także skalować.

Keyframed_movement_component używa keyframed_movement_delta jako typu klatki kluczowej. Te delty ruchu mają trzy wartości:

• Przekształć: Określa zmiany w przekształceniu względem poprzedniej klatki kluczowej.

• Czas trwania: Czas trwania klatki kluczowej w sekundach.

• Dynamika: funkcja dynamiki używana podczas odtwarzania tej klatki kluczowej.

Keyframed_movement_component pobiera tablicę klatek kluczowych, a następnie je odtwarza, dlatego musisz podać wszystkie klatki kluczowe za jednym razem dla każdej animacji, która ma być odtwarzana. Można to zrobić na dwa sposoby:

1. Można utworzyć w kodzie tablicę złożoną z wielu klatek kluczowych, a następnie przekazać ją do komponentu ruchu w klatce kluczowej i odtworzyć pojedynczą animację.

2. Możesz utworzyć wiele tablic zawierających pojedynczą klatkę kluczową i przekazywać je indywidualnie do komponentu ruchu w klatce kluczowej, aby odtworzyć kolejno wiele animacji.

Obie te opcje wymagają kompromisów. Tablice pojedynczych klatek kluczowych ułatwiają wykonywanie operacji między klatkami kluczowymi, ale wymagają więcej kodu do przetworzenia. Utworzenie wszystkich klatek kluczowych jednocześnie ułatwia zarządzanie, ale trudniej jest wykonywać operacje podczas odtwarzania animacji. Zarówno samouczek Animacja ruchu rekwizytów, jak i ten samouczek, dotyczą pierwszego podejścia, ale dostarczona zostanie również implementacja drugiego podejścia.

Aby utworzyć indywidualne klatki kluczowe w kodzie, zdefiniujesz klasę segment. Każdy segment będzie reprezentował klatkę kluczową używaną przez komponent keyframed_movement_component, który możesz utworzyć w edytorze. Możesz też uwzględnić dodatkowe dane, takie jak ilość czasu oczekiwania między każdą klatką kluczową. Wykonaj poniższe kroki, aby utworzyć klasę segmentu.

1. Dodaj nową klasę o nazwie segment do pliku animate_to_targets_component.verse. Dodaj specyfikator <concrete>, aby umożliwić używanie tej klasy jako wartości @editable.

   Verse

   # Defines a segment of animation, which includes a starting position, animation speed and duration, and easing function.
   # Each segment acts as a single animation, and multiple segments make up an animation sequence.
   segment<public> := class<concrete>:

   Copy full snippet(3 lines long)

2. Do swojej definicji klasy segmentu dodaj następujące pola:

   • Opcja edytowalnej jednostki o nazwie SegmentStartPosition. Jednostka ta będzie pełniła funkcję odwołania do pozycji w świecie, od której jednostka ma rozpocząć animację.

   Verse

   # An entity that represents the starting position of this entity during the animation segement.
   @editable:
       ToolTip := SourceTip
   SegmentStartPosition:?entity = false

   Copy full snippet(4 lines long)

   • Edytowalna wartość zmiennopozycyjna o nazwie AnimationDuration. Jest to czas potrzebny do odtworzenia tego segmentu animacji. Ustaw tę wartość na 2.0, aby odtworzenie każdego segmentu animacji trwało dwie sekundy.  

   Verse

   # The duration of the animation segment.
   @editable:
       ToolTip := AnimationDurationTip
   AnimationDuration:float = 2.0

   Copy full snippet(4 lines long)

   • Edytowalna opcja kontroli dynamiki o nazwie EasingFunction. Jest to funkcja łagodzenia używana w tym segmencie animacji.  

   Verse

   # The easing function to use during this segment of animation.
   @editable:
       ToolTip := EasingFunctionTip
   EasingFunction:?easing_function = false

   Copy full snippet(4 lines long)

   Każda funkcja łagodzenia jest zdefiniowana za pomocą krzywej Béziera trzeciego stopnia, która składa się z czterech liczb tworzących typ funkcji łagodzenia stosowany przez animację. Np. parametry krzywej łagodzenia na początku powodują, że animacja zwalnia na początku, a następnie przyspiesza.

   Parametry krzywej liniowej sprawiają, że animacja jest odtwarzana w stałym tempie. Możesz samodzielnie definiowanie te wartości, aby utworzyć własne niestandardowe krzywe animacji, ale nie musisz w tym przykładzie, ponieważ będziesz używać wartości zdefiniowanych w moduł KeyframedMovement.

   • Edytowalna opcja wartości zmiennopozycyjnej o nazwie PauseSeconds. jest to czas w sekundach do pauzy przed rozpoczęciem tego segmentu animacji. Można to sobie wyobrazić jako ilość czasu, w którym jednostka się zatrzymuje, zanim przejdzie z każdego punktu na swojej ścieżce.  

   Verse

   # The number of seconds to pause before starting this animation segment.
   @editable:
       ToolTip := PauseTip
   PauseSeconds:?float = false

   Copy full snippet(4 lines long)

3. W definicji klasy animate_to_targets_component dodaj następujące pola:

   • Edytowalna tablica segmentów o nazwie Segments (Segmenty). Będzie to odwołanie do każdego segmentu animacji, który składa się na ogólną animację, przez którą przechodzi jednostka.

   Verse

   # Segments of the keyframed movement animation.
   @editable:
       ToolTip := SegmentsTip
   var Segments<private>:[]segment = array{}

   Copy full snippet(4 lines long)

   • Edytowalna funkcja kontroli dynamiki o nazwie DefaultEasingFunction. Jeśli segment animacji nie określa funkcji dynamiki, będzie używana domyślnie. Ustaw to na ease_in_out_cubic_bezier_easing_function.  

   Verse

   # Movement easing function between two targets
   @editable:
       ToolTip := DefaultEasingFunctionTip
   var DefaultEasingFunction<public>:easing_function = ease_in_out_cubic_bezier_easing_function{}

   Copy full snippet(4 lines long)

4. Zapisz kod i go skompiluj. W edytorze przy jednostkach powinna pojawić się tablica Segmenty przy tych jednostkach, które mają dołączony animate_to_targets_component.

Tworzenie klatek kluczowych za pomocą kodu

Gdy klasa segmentu będzie gotowa, czas utworzyć klatki kluczowe definiowane przez segmenty. Zbudujesz klatki kluczowe pojedynczo i dodasz je do tablicy, a następnie przekażesz tablicę do swojego keyframed_movement_component. Będzie to wymagało odrobiny matematyki, którą zdefiniujemy właśnie teraz.

Operacje matematyczne są przydatne w różnych scenariuszach, dlatego dobrze jest umieścić tę logikę w pliku narzędziowym, aby mieć do niej dostęp z dowolnego komponentu Verse. Aby dowiedzieć się więcej na temat dobrych praktyk Verse podczas pracy z jednostkami, patrz: Tworzenie własnego komponentu Verse. Aby utworzyć plik narzędziowy, wykonaj następującą procedurę:

1. Utwórz w pliku animate_to_targets.verse nowy moduł o nazwie Utilities. przechowa wspólną logikę, której będziesz używać w swoim projekcie.

   Verse

   # Module containing utility functions.
   Utilities<public> := module:
   

   Copy full snippet(2 lines long)

2. Dodaj nowy alias typu vector3 o nazwie VectorOnes do modułu Narzędzia, który będzie tworzył vector3, gdzie ustawienia Lewo, Prawo i Góra mają wartość 1.0. Będziesz używać tego wektora później, aby usprawnić pewne obliczenia matematyczne, dlatego zdefiniowanie aliasu typu oznacza, że nie musisz wielokrotnie pisać vector3{Left := 1.0, Up := 1.0, Forward := 1.0}. Ponieważ zaimportowano zarówno i /UnrealEngine.com/Temporary/SpatialMath moduły, musisz określić, że jest to plik /Verse.org/SpatialMath vector3, ponieważ oba moduły zawierają jego definicję.

   Verse

   # Utility function for the identity of component-wise vector multiplication.
   VectorOnes<public>()<transacts>:(/Verse.org/SpatialMath:)vector3 = (/Verse.org/SpatialMath:)vector3{Left := 1.0, Up := 1.0, Forward := 1.0}

   Copy full snippet(2 lines long)

3. Dodaj nową funkcję o nazwie GetDeltaTransform() do modułu Narzędzia. Funkcja ta obliczy różnicę między dwoma przekształceniami i zwróci wartość delta. Dodaj modyfikator <transacts> do tej funkcji, aby zezwolić na jej wycofywanie do poprzedniej wersji. Określ /Verse.org/SpatialMath jako moduł dla każdego Przekształć, ponieważ będziesz obliczać różnicę między przekształceniami jednostek.

   Verse

   # Get the delta transform between two given transforms.
   GetDeltaTransform<public>(TransformOne:(/Verse.org/SpatialMath:)transform, TransformTwo:(/Verse.org/SpatialMath:)transform)<transacts>:(/Verse.org/SpatialMath:)transform=

   Copy full snippet(2 lines long)

4. W GetDeltaTransform zainicjuj nowe /Verse.org/SpatialMath będące przekształceniem. Ustaw translację na różnicę między translacjami każdego przekształcenia. Ustaw obrót na wynik wywołania MakeComponentWiseDeltaRotation(). Funkcja ta znajduje się w module /UnrealEngine.com/Temporary/SpatialMath, więc musisz dokonać konwersji z obrotów /Verse.org/SpatialMath na obroty /UnrealEngine.com/Temporary/SpatialMath. Można to zrobić za pomocą funkcji FromRotation(). Wywołaj MakeComponentWiseDeltaRotation(), przekazując obrót każdego przekształcenia po skonwertowaniu go za pomocą FromRotation(). Następnie skonwertuj wynik tego wywołania funkcji ponownie przy użyciu FromRotation(), aby przekonwertować z powrotem na /Verse.org/SpatialMath obrót. Na końcu ustaw skalę na wynik sumy wartości VectorOnes i różnicy między pierwszą a drugą skalą podzielonej przez pierwszą skalę. Gwarantuje to prawidłowe skalowanie jednostki podczas animacji. Gotowa funkcja GetDeltaTransform() powinna wyglądać następująco:

   Verse

   # Get the delta transform between two given transforms.
   GetDeltaTransform<public>(TransformOne:(/Verse.org/SpatialMath:)transform, TransformTwo:(/Verse.org/SpatialMath:)transform)<transacts>:(/Verse.org/SpatialMath:)transform=
       (/Verse.org/SpatialMath:)transform:
           Translation := TransformTwo.Translation - TransformOne.Translation
           Rotation := FromRotation(MakeComponentWiseDeltaRotation(
               FromRotation(TransformTwo.Rotation), 
               FromRotation(TransformOne.Rotation)))
           Scale := VectorOnes() + ((TransformTwo.Scale - TransformOne.Scale) / TransformOne.Scale)

   Copy full snippet(8 lines long)

5. Na końcu dodaj funkcję o nazwie TryGetvalueOrDefault() do modułu Utilities i dodaj do niej modyfikator <transacts>. Funkcja ta przyjmuje wartość opcji określonego typu oraz wartość domyślną tego samego typu i return wartość domyślną lub przedmiot w obrębie Value, jeśli taki istnieje. Jest to przydatne, gdy chcesz sprawdzić, czy wartość w klasie jest rzeczywiście zainicjowana, i gwarantuje, że zwrócisz jakąś wartość, jeśli nie jest. W TryGetValueOrDefault() sprawdź, czy Value zawiera wartość i zwraca ją. W przeciwnym razie zwróć Default (wartość domyślną). Gotowy moduł Utilities i funkcja TryGetValurOrDefault() powinny wyglądać następująco:

   Verse

   # Module containing utility functions.
   Utilities<public> := module:
       
       
       # Utility function for the identity of component-wise vector multiplication.
       VectorOnes<public>()<transacts>:(/Verse.org/SpatialMath:)vector3 = (/Verse.org/SpatialMath:)vector3{Left := 1.0, Up := 1.0, Forward := 1.0}
       
       
       # Get the delta transform between two given transforms.
       GetDeltaTransform<public>(TransformOne:(/Verse.org/SpatialMath:)transform, TransformTwo:(/Verse.org/SpatialMath:)transform)<transacts>:(/Verse.org/SpatialMath:)transform=
   
   Expand code Copy full snippet(24 lines long)

Po zdefiniowaniu matematyki możesz tworzyć klatki kluczowe z kodu!

Aby utworzyć funkcje tworzenia klatek kluczowych, wykonaj poniższe kroki:

1. Dodaj nową funkcję o nazwie ConstructKeyframe() do definicji klasy animate_to_targets. W tej funkcji stosuje się jednostkę źródłową, jednostkę docelową, opcjonalną funkcję dynamiki jazdy oraz czas trwania. Zwraca nawet tablicę keyframed_movements_delta.

   Verse

   # Construct a single keyframe that animates between the Source and Destination entity using the given easing function over a set duration.
   ConstructKeyframe<private>(Source:entity, Destination:entity, Easing:?easing_function, Duration:float)<transacts><decides>:[]keyframed_movement_delta=

   Copy full snippet(2 lines long)

2. W ConstructKeyframe() najpierw pobierz przekształcenia jednostek Source i Destination, wywołując GetGlobalTransform().

   Verse

   # Construct a single keyframe which animates between the Source and Destination entity using the given easing function over a set duration.
   ConstructKeyframe<private>(Source:entity, Destination:entity, EasingFunction:easing_function, Duration:float)<transacts><decides>:[]keyframed_movement_delta=
       var SourceTransform:(/Verse.org/SpatialMath:)transform = Source.GetGlobalTransform()
       var DestinationTransform:(/Verse.org/SpatialMath:)transform = Destination.GetGlobalTransform()

   Copy full snippet(4 lines long)

3. Inicjowanie tablicy za pomocą jednego elementu keyframed_movement_delta. Ustaw przekształcenie na wynik wywołania GetDeltaTransform(), przekazując przekształcenie źródłowe i docelowe, a następnie ustaw czas trwania i łagodzenie na wartości przekazane do tej funkcji. Gotowa funkcja ConstructKeyframe() powinna wyglądać następująco:

   Verse

   # Construct a single keyframe which animates between the Source and Destination entity using the given easing function over a set duration.
   ConstructKeyframe<private>(Source:entity, Destination:entity, EasingFunction:easing_function, Duration:float)<transacts><decides>:[]keyframed_movement_delta=
       var SourceTransform:(/Verse.org/SpatialMath:)transform = Source.GetGlobalTransform()
       var DestinationTransform:(/Verse.org/SpatialMath:)transform = Destination.GetGlobalTransform()
       array:
           keyframed_movement_delta:
               Transform := Utilities.GetDeltaTransform(SourceTransform, DestinationTransform)
               Duration := Duration
               Easing := EasingFunction

   Copy full snippet(9 lines long)

Funkcja ta buduje poszczególne klatki kluczowe, ale do zbudowania pełnych animacji potrzebujesz więcej logiki. 

1. Dodaj nową funkcję o nazwie ConstructAndPlayAnimations() do definicji klasy animate_to_targets. Funkcja ta pobiera tablicę segmentów oraz tryb odtwarzania animacji, a następnie używa ich do tworzenia oraz odtwarzania pełnej animacji. Dodaj modyfikator <suspends> do tej funkcji, aby umożliwić uruchamianie jej w sposób asynchroniczny.

   Verse

   # Construct and play an animation from an array of animation segments.
   ConstructAndPlayAnimations<private>(InSegments:[]segment, AnimationPlayback:keyframed_movement_playback_mode)<suspends>:void=

   Copy full snippet(2 lines long)

2. W ConstructAndPlayAnimations() zdefiniuj nową zmienną logiczną o nazwie ShouldBreakOut i zainicjuj ją na false. Biorąc pod uwagę trzy tryby odtwarzania ruchu z klatkami kluczowymi, należy traktować każdy z nich osobno. Wykorzystasz wyrażenie loop do ciągłego budowania animacji w celu obsługi trybów pętli ping pongowej, ale tryb one-shot powinien zakończyć się po zakończeniu pierwszej iteracji. Sprawdź, czy tryb odtwarzania animacji jest trybem jednorazowym, a jeśli tak, ustaw dla ShouldBreakOut wartość true.

   Verse

   # Construct and play an animation from an array of animation segments.
   ConstructAndPlayAnimations<private>(InSegments:[]segment, AnimationPlayback:keyframed_movement_playback_mode)<suspends>:void=
           
       var ShouldBreakOut:logic = false
       # If this is a oneshot animation, break out of loop after it plays once.
       if (oneshot := oneshot_keyframed_movement_playback_mode[AnimationPlayback]):
           set ShouldBreakOut = true

   Copy full snippet(7 lines long)

3. Następnie w wyrażeniu if pobierz keyframed_movement_component jednostki w zmiennej KeyframedMovementComponent.  Następnie pobierz przekształcenie początkowe animacji w zmiennej o nazwie StartingTransform, pobierając pierwszy element tablicy InSegments, a następnie jego przekształcenie globalne.

   Verse

   # Position this entity in the correct starting position.
   if:
       KeyframedMovementComponent := Entity.GetComponent[keyframed_movement_component]
       StartingTransform :=
           FirstSegment := InSegments[0].SegmentStartPosition?.GetGlobalTransform()

   Copy full snippet(5 lines long)

4. Na koniec umieść jednostkę w jej lokalizacji początkowej, ustawiając dla niej transformację globalną na transformację początkową i uśpij przez okres InitialPauseSeconds przed odtworzeniem animacji.

   Verse

   # Position this entity in the correct starting position.
   if:
       KeyframedMovementComponent := Entity.GetComponent[keyframed_movement_component]
       StartingTransform :=
       FirstSegment := InSegments[0].SegmentStartPosition?.GetGlobalTransform()
   
   then:
       Entity.SetGlobalTransform(StartingTransform)
       # Sleep for initial pause.
       Sleep(InitialPauseSeconds)

   Copy full snippet(10 lines long)

5. Teraz czas utworzyć tablicę klatek kluczowych, z której zostanie zbudowana animacja. Najpierw zainicjuj nową tablicę zmiennych keyframed_movement_delta o nazwie Keyframes. Następnie w wyrażeniu for wykonaj iterację po każdym segmencie w tablicy InSegments, pobierając zarówno segment, jak i jego indeks w zmiennej lokalnej o nazwie Index.

   Verse

   # Build the array of keyframes to play the animation from.
   var Keyframes:[]keyframed_movement_delta = array{}
   for:
       Index -> Segment:InSegments
       SourceEntity := Segment.SegmentStartPosition?
       DestinationEntity := InSegments[Index + 1].SegmentStartPosition?

   Copy full snippet(6 lines long)

6. Teraz pobierz funkcję dynamiki jazdy używaną dla tej klatki kluczowej w zmiennej lokalnej o nazwie Dynamika dynamiki, wywołując TryGetValueOrDefault(), przekazując Segment.EasingFunction i DefaultEasingFunction. Pobierz również czas trwania segmentu animacji w zmiennej lokalnej Duration z Segment.AnimationDuration. Po wprowadzeniu wszystkich wartości w wyrażeniu if utwórz klatkę kluczową, przekazując każdą wartość do ConstructKeyframe[], a następnie dodaj wynik do tablicy Klatek kluczowych. Po utworzeniu wszystkich klatek kluczowych Zestaw tablicę klatek kluczowych na komponent ruchu z klatkami kluczowymi, wywołując funkcję SetKeyframes() przekazującą tablicę klatek kluczowych oraz funkcję PlaybackMode.

   Verse

   # Build the array of keyframes to play the animation from.
   var Keyframes:[]keyframed_movement_delta = array{}
   for:
       Index -> Segment:InSegments
       SourceEntity := Segment.SegmentStartPosition?
       DestinationEntity := InSegments[Index + 1].SegmentStartPosition?
   do:
       Easing := Utilities.TryGetValueOrDefault(Segment.EasingFunction, DefaultEasingFunction)
       Duration := Segment.AnimationDuration
       # Construct each keyframe and add it to the array.
   
   Expand code Copy full snippet(15 lines long)

7. Po ustawieniu tablicy klatek kluczowych czas zacząć je odtwarzać. Animacja musi być wykonywana w pętli, ale powinna zostać zatrzymana po pierwszej iteracji, jeśli tryb animacji jest ustawiony na jedno ujęcie. Musi też obsługiwać wstrzymywanie na każdą klatkę kluczową, jeśli segment zawiera jakieś PauseSeconds. Aby to obsłużyć, skonfiguruj wyrażenie loop zawierające wyrażenie for. W wyrażeniu for wykonaj iterację po każdej klatce kluczowej na tablicy klatek kluczowych, dodatkowo uzyskując indeks każdej klatki kluczowej w zmiennej KeyframeIndex.

   Verse

   KeyframedMovementComponent.SetKeyframes(Keyframes, PlaybackMode)
   
   # Loop playing the animation from the keyframed_movement_component, pausing at each
   # keyframe for a specified duration. Will break out of the loop if the animation mode
   # is set to oneshot.
   loop:
       for(KeyframeIndex -> Keyframe:Keyframes):

   Copy full snippet(7 lines long)

8. Wewnątrz wyrażenia for pobierz segment powiązany z tą klatką kluczową, indeksując w tablicy InSegments przy użyciu KeyframeIndex. Następnie, jeśli segment zawiera jakiekolwiek PauseSeconds, wywołuj Sleep() na ten czas. Następnie wywołaj KeyframedMovementComponent.Play(), po czym wyczekuj zdarzenia KeyframeReachedEvent i wywołaj KeyframedMovementComponent.Pause(). Ta funkcja wstrzymuje animację przy każdej klatce kluczowej na czas PauseSeconds, po czym odtwarza i oczekuje na kolejną klatkę kluczową, a następnie ponownie ją zatrzyma. Na końcu wyrażenia loop sprawdź, czy ShouldBreakOut ma wartość true, a jeśli tak, przerwij pętlę.

   Verse

   # Loop playing the animation from the keyframed_movement_component, pausing at each
   # keyframe for a specified duration. Will break out of the loop if the animation mode
   # is set to oneshot.
   loop:
       for(KeyframeIndex -> Keyframe:Keyframes):
           if:
               SegmentReached := InSegments[KeyframeIndex]
           then:
               Sleep(SegmentReached.PauseSeconds)
               KeyframedMovementComponent.Play()
   
   Expand code Copy full snippet(14 lines long)

9. Gotowa funkcja ContstructAndPlayAnimations() powinna wyglądać następująco:

   Verse

   # Construct and play an animation from an array of animation segments.
   ConstructAndPlayAnimations<private>(InSegments:[]segment, AnimationPlayback:keyframed_movement_playback_mode)<suspends>:void=
           
       var ShouldBreakOut:logic = false
       # If this is a oneshot animation, break out of loop after it plays once.
       if (oneshot := oneshot_keyframed_movement_playback_mode[AnimationPlayback]):
           set ShouldBreakOut = true
       
       
       # Position this entity in the correct starting position.
   
   Expand code Copy full snippet(51 lines long)

W kolejnym kroku utworzysz gotowiec animowanej jednostki, a następnie dodasz jego instancję w poziomie.

Następnie

• 

  3. Tworzenie platformówki przy użyciu gotowców

  Użyj Scene Graph i Verse, aby zbudować własną platformówkę.