1. Epic GamesDeveloper
  3. 3. Wyszukiwanie świateł w środowisku uruchomieniowym za pomocą tagów rozgrywki

3. Wyszukiwanie świateł w środowisku uruchomieniowym za pomocą tagów rozgrywki

Tworzenie łamigłówki wykorzystującej urządzenie utworzone w języku Verse, w której gracz musi znaleźć właściwą kombinację włączonych i wyłączonych świateł, aby zespawnować przedmiot.

3. Wyszukiwanie świateł w środowisku uruchomieniowym za pomocą tagów rozgrywki
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

Wykonując ten krok w samouczku Łamigłówka z otagowanymi światłami, nauczysz się wykorzystywać tagi rozgrywki do wyszukiwania aktorów oznaczonych konkretnym tagiem, gdy gra jest uruchomiona. Tagi rozgrywki umożliwiają pracę z wieloma urządzeniami bez konieczności konfigurowania ich odwołań w edytorze. Daje to możliwość tworzenia interesujących rozgrywek, w których na przykład kod zmienia dynamicznie aktywne urządzenia w miarę postępów gracza w grze.

Aby utworzyć nowy tag rozgrywki i przypisać go do wszystkich świateł danego poziomu w łamigłówce, wykonaj następujące instrukcje:

  1. Otwórz Eksplorator Verse i kliknij dwukrotnie plik tagged_lights_puzzle.verse, aby otworzyć skrypt w Visual Studio Code.
  2. U góry pliku z kodem:
    • Dodaj wiersz using { /Verse.org/Simulation/Tags }, aby utworzyć odwołanie do klasy tag i użyć funkcji GetCreativeObjectsWithTag().
    • Dodaj wiersz using { /Verse.org/Simulation }, aby ustawić możliwość edycji właściwości.
     using { /Fortnite.com/Devices }
 using { /Verse.org/Native }
 using { /UnrealEngine.com/Temporary/Diagnostics }
 using { /Verse.org/Simulation/Tags }
 using { /Verse.org/Simulation }
    
 log_tagged_lights_puzzle := class(log_channel){}

  3. Nad klasą log_tagged_lights_puzzle dodaj nową podklasę o nazwie puzzle_light, która będzie dziedziczyć z klasy tag. Nazwa dziedziczonej klasy stanie się niestandardowym tagiem rozgrywki, który będzie można zastosować do dowolnego urządzenia w trybie kreatywnym.

     # Wyprowadź z klasy `tag` w module Verse.org/Simulation/Tags, aby utworzyć nowy tag rozgrywki.
 puzzle_light := class(tag){}

 log_tagged_lights_puzzle := class(log_channel){}
  4. Na pasku narzędzi UEFN kliknij opcję Kompiluj skrypty Verse, aby skompilować swój kod oraz nowy tag rozgrywki puzzle_light do swojego projektu.
  5. W obszarze Outliner w UEFN wybierz opcję Urządzenie konfigurowalnego światła, aby otworzyć jego panel Szczegóły.
  6. W panelu Szczegóły:
    1. Kliknij opcję Dodaj nowy komponent i wybierz pozycję Znacznik tagu Verse.
    2. Wybierz komponent VerseTagMarkup, aby wyświetlić jego ustawienia w panelu Szczegóły.
    3. W obszarze Tagi rozgrywki edytuj właściwość Tagi i dodaj tag puzzle_light.
    Dodawanie komponentu VerseTagMarkup oraz tagu puzzle_light

    Do jednego urządzenia można dodać wiele tagów, dlatego każde urządzenie może równocześnie należeć do wielu grup. Na przykład urządzenie oznaczone tagami tag1 i tag2 zostanie znalezione w przypadku wywołania zarówno funkcji GetCreativeObjectsWithTag(tag1{}), jak i funkcji GetCreativeObjectsWithTag(tag2{}).
  7. W definicji klasy tagged_lights_puzzle dodaj dwa pola tablicy zmiennych:
    • Edytowalna tablica zmiennych logic o nazwie LightsState, która będzie odzwierciedlać bieżący stan wszystkich świateł (ich włączenia lub wyłączenia). Posłuży ona również do ustalenia stanu początkowego świateł, tak aby liczba zawartych w nich elementów była zgodna z liczbą świateł oznaczonych tagiem puzzle_light. W tym przykładzie wszystkie światła są domyślnie wyłączone, dlatego wartością początkową wszystkich świateł jest false. 
       @editable
 var LightsState : []logic = array{false, false, false, false}
    • Edytowalna tablica zmiennych customizable_light_device o nazwie Lights, w której przechowywane będą wszystkie urządzenia konfigurowalnego światła oznaczone tagiem rozgrywki puzzle_light. 
       @editable
 var Lights : []customizable_light_device = array{}
  8. Po rozpoczęciu gry urządzenie powinno ustawić światła zgodnie z początkową konfiguracją zdefiniowaną w tablicy LightsState i zapisać odwołania w tablicy Lights, aby można je było aktualizować w przypadku zmian stanu gry. Praca ta będzie realizowana w metodzie SetupPuzzleLights() : void i wywoływana w metodzie OnBegin(), aby światła zostały ustawione, gdy gra się rozpocznie. 
     SetupPuzzleLights() : void =
     Logger.Print(“Konfigurowanie świateł w grze”)
    
 OnBegin<override>()<suspends> : void =
     SetupPuzzleLights()
  9. W metodzie SetupPuzzleLights() wyszukaj wszystkie urządzenia oznaczone tagiem puzzle_light, wywołując funkcję GetCreativeObjectsWithTag(puzzle_light{}), i zapisz je w tablicy o nazwie TaggedActors. Tablica TaggedActors jest tablicą stałą, której zakres jest lokalny względem metody SetupPuzzleLights(), dlatego nie musisz w sposób jawny określać typu tablicy, ponieważ w tym kontekście zostanie on domniemany. 
     SetupPuzzleLights() : void =
     Logger.Print("Konfigurowanie świateł w grze")
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})

    Różne wywołania funkcjiGetCreativeObjectsWithTag() mogą zwracać tablice wynikowe zawierające urządzenia w różnej kolejności, ponieważ przy pobieraniu aktorów za pomocą tagów rozgrywki kolejność nie jest gwarantowana.
  10. Po zebraniu wszystkich urządzeń oznaczonych tagiem puzzle_light upewnij się, że każde światło jest zgodne ze stanem początkowym określonym za pomocą tablicy LightsState. Użycie pętli for pozwala na iterowanie przez wszystkie otagowane urządzenia. 
     for:
     ActorIndex -> TaggedActor : TaggedActors
 do:
     TaggedActor
  11. Funkcja GetCreativeObjectsWithTag() zwraca tablicę typu creative_object_interface. W tym przykładzie chcesz wejść w interakcję z każdym obiektem TaggedActor będącym obiektem typu customizable_light_device, aby móc włączać i wyłączać światło.
    • Możesz skonwertować klasę na jedną z jej podklas (operacja nazywana rzutowaniem typu), wykorzystując składnię NewDeviceReference := device_type_to_cast_to[DeviceReference], w której device_type_to_cast_to jest pożądanym typem urządzenia, czyli w tym przykładzie customizable_light_device. Jest to wyrażenie zawodne, ponieważ konwersja typu nie powiedzie się, jeśli nie można skonwertować urządzenia do tego typu (na przykład w przypadku urządzenia innego typu). 
       LightDevice := customizable_light_device[TaggedActor]

    Funkcja GetCreativeObjectsWithTag() zawiera typ informacji zwrotnej []creative_object_interface, ponieważ funkcja może zwracać różne typy aktorów, zatem typem zwracanej przez nią informacji jest interfejs, jaki muszą implementować wszyscy aktorzy, aby byli zwracani po wywołaniu funkcji GetCreativeObjectsWithTag(). Aby dowiedzieć się więcej, patrz tagi rozgrywki.
    • Wyrażenia for pozwalają użyć wyrażeń zawodnych jako filtra i tworzyć nowe zmienne, które następnie można wykorzystać w bloku kodu for. W tym przypadku dodaj konwersję typu do customizable_light_device z poprzedniego kroku do wyrażenia iteracyjnego. 
       for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • Ostatnie wyrażenie w bloku kodu jest wynikiem bloku kodu. Wyrażenie for zwraca wynik bloku kodu z każdej iteracji w tablicy, więc wynik tego wyrażenia for jest tablicą odwołań do obiektów customize_light_device oznaczonych tagiem puzzle_light. To oznacza, że można zaktualizować tablicę Lights bezpośrednio o wynik wyrażenia for. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
 do:
      LightDevice
    • Ta pętla for powinna również wywoływać funkcje TurnOn() / TurnOff() w odniesieniu do świateł zgodnie z ich ustawieniem początkowym LightsState w edytorze. Wyrażenie for może zwrócić indeks używany do pobierania bieżącego urządzenia oznaczonego tagiem (w tym przykładzie ActorIndex), który można wykorzystać do indeksowania w tablicy LightsState w celu sprawdzenia, czy światło można włączyć lub wyłączyć. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn:= LightsState[ActorIndex]
 do:
      LightDevice
    • Następnie wywołaj funkcję TurnOn() / TurnOff() w zależności od tego, czy ShouldLightBeOn przyjmuje wartość true czy false. Wyrażenia if można używać do wykonywania różnych wyrażeń w zależności od stanu (a zwłaszcza wyrażenia zawodnego). W tym przypadku w wyrażeniu zawodnym można zastosować operator zapytania ? w połączeniu z wyrażeniem IsLightOn, które powiedzie się, gdy ShouldLightBeOn przyjmie wartość true (wywołując funkcję TurnOn()), i zakończy się niepowodzeniem, gdy ShouldLightBeOn przyjmie wartość false (wywołując funkcję TurnOff()). 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[TaggedActor]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
    • Dobrym rozwiązaniem jest wygenerowanie indeksu światła wraz z jego wartością początkową za pomocą polecenia print w celu sprawdzenia, czy kod działa zgodnie z oczekiwaniami i porównania go z efektem widocznym w poziomie.
    • Zastosowanie nawiasu {} w środku ciągu tekstowego sprawi, że wyrażenie w nawiasie {} zostanie poddane ocenie jako pierwsze, a jego wartość zostanie dodana do ciągu tekstowego. Możesz zatem zastosować wyrażenie if w środku ciągu tekstowego, aby warunkowo dodać wartości. 
       set Lights = for:
      ActorIndex -> TaggedActor : TaggedActors
      LightDevice := customizable_light_device[ActorIndex]
      ShouldLightBeOn := LightsState[ActorIndex]
 do:
      Logger.Print("Dodawanie światła pod indeksem {ActorIndex} ze stanem:{if (ShouldLightBeOn?) then "On" else "Off"}")
      if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
      LightDevice
  12. Otrzymana metoda SetupPuzzleLights() powinna wyglądać następująco: 
     SetupPuzzleLights() : void =
     TaggedActors := GetCreativeObjectsWithTag(puzzle_light{})
     <#
     Dla każdego urządzenia oznaczonego tagiem puzzle_light, sprawdź, czy jest ono obiektem typu customizable_light_device, wykonując próbę rzutowania go do tego typu.
     Jeśli tak, pobierz jego stan LightState, aby włączyć za pomocą funkcji TurnOn() lub wyłączyć za pomocą funkcji TurnOff() urządzenie LightDevice.
     Zapisz wszystkie obiekty customizable_light_device oznaczone tagiem w tablicy świateł Lights.
     #>
     set Lights = for:
             ActorIndex -> TaggedActor : TaggedActors
             LightDevice := customizable_light_device[TaggedActor]
             ShouldLightBeOn := LightsState[ActorIndex]
     do:
             Logger.Print("Dodawanie światła pod indeksem {ActorIndex} ze stanem:{if (ShouldLightBeOn?) then "On" else "Off"}")
             if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff()
             LightDevice
  13. Zapisz skrypt w Visual Studio Code.
  14. Na pasku narzędzi UEFN kliknij opcję Kompiluj skrypty Verse, aby skompilować swój kod.
  15. Na pasku narzędzi UEFN kliknij przycisk Odtwórz, aby przetestować poziom w grze.

W trakcie wykonywania testu gry poziomu każde światło dodane do tablicy Lights wraz ze stanem początkowym powinno zostać wyświetlone w rejestrze wyjściowym.

Następny krok

W kolejnym kroku tego samouczka dowiesz się, jak przełączać konkretny zbiór świateł, gdy gracz naciska przyciski.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page