Kodowanie interakcji z urządzeniem

Jeśli znasz Bezpośrednie powiązanie zdarzenia, to wiedz, że koncepcja zdarzeń i funkcji, z którymi pracujesz na urządzeniach trybu kreatywnego, przekłada się również na Verse. Możesz użyć Verse do zakodowania własnych funkcji i zachowań, które będą uruchamiane po wystąpieniu zdarzeń!

W poniższych sekcjach opisano różne sposoby pracy ze zdarzeniami urządzenia trybu kreatywnego w aplikacji Verse i kodowania własnej logiki.

Powiązywanie funkcji do zdarzeń urządzenia trybu kreatywnego

Można subskrybować zdarzenia, które urządzenia trybu kreatywnego uwidaczniają w swoich interfejsach API. na przykład, klasa urządzenia przycisku button_device uwidacznia InteractedWithEvent, które występuje za każdym razem, gdy gracz wchodzi w interakcję z urządzeniem przycisku. Możesz wywołać Subscribe() na zdarzeniu i przekazać identyfikator funkcji, którą chcesz wywołać za każdym razem, gdy zdarzenie zostanie zasygnalizowane.

Subskrybowanie pozwala określić funkcję, która ma zostać wywołana, gdy zdarzenie zostanie zasygnalizowane, co nazywamy powiązaniem ze zdarzeniem. Powiązana funkcja to procedura obsługi. W przykładzie poniżej procedurą obsługi jest OnButtonInteractedWith.

W zależności od definicji zdarzenia sygnatura funkcji musi odpowiadać temu, co zdarzenie ma wywołać. Na przykład, subskrybowanie zdarzenia InteractedWithEvent dla button_device oczekuje otrzymania funkcji z jednym parametrem typu agent, zatem funkcja OnButtonInteractedWith powinna wyglądać następująco:

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

hello_world_device := class(creative_device):
    @editable
    MyButtonDevice:button_device = button_device{}

    OnBegin<override>()<suspends>:void=
        # Powiąż funkcję OnButtonInteractedWith ze zdarzeniem InteractedWithEvent urządzenia przycisku
        MyButtonDevice.InteractedWithEvent.Subscribe(OnButtonInteractedWith)

    OnButtonInteractedWith(InAgent:agent):void=
        Print("Gracz wszedł w interakcję z przyciskiem!")
Copy full snippet

using { /Fortnite.com/Devices } using { /Verse.org/Simulation } hello_world_device := class(creative_device): @editable MyButtonDevice:button_device = button_device{} OnBegin<override>()<suspends>:void= # Powiąż funkcję OnButtonInteractedWith ze zdarzeniem InteractedWithEvent urządzenia przycisku MyButtonDevice.InteractedWithEvent.Subscribe(OnButtonInteractedWith) OnButtonInteractedWith(InAgent:agent):void= Print("Gracz wszedł w interakcję z przyciskiem!")

Gdy wywołasz funkcję Subscribe() na rzecz zdarzenia urządzenia, funkcja zwróci wynik cancelable. Wywołanie funkcji Cancel() na rzecz zmiennej, która jest cancelable, spowoduje anulowanie subskrypcji funkcji obsługującej zdarzenie, dzięki czemu funkcja nie będzie już wywoływana po zasygnalizowaniu zdarzenia.

Jeśli chcesz przechowywać pojedynczy wynik, który cancelable , możesz użyć kontenera takiego jak option. Nie możesz bezpośrednio utworzyć zmiennej cancelable, ale możesz skonfigurować zmienną option, która będzie przechowywać wynik subskrypcji.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

spawner_button := class(creative_device):

    @editable
    Button:button_device = button_device{}

    # Kontener do przechowywania subskrypcji zdarzenia
    var ButtonSubscription:?cancelable = false

    OnBegin<override>()<suspends>:void=
        ButtonSubscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith)

        # Ustaw wynik możliwy do anulowania jako wartość w zmiennej opcji.
        set ButtonSubscription = option{Subscription}
        Print("Subskrypcja zdarzenia InteractedWithEvent przycisku i przypisano subskrypcję do ButtonSubscription!")

    OnButtonInteractedWith(InPlayer:agent):void=
        Print("Gracz wszedł w interakcję z przyciskiem!")

        # Dostęp do zmiennej możliwej do anulowania dla subskrypcji InteractedWithEvent
        if(CancelableResult := ButtonSubscription?):
            CancelableResult.Cancel()
            Print("Anulowano to InteractedWithEvent")
Copy full snippet

using { /Fortnite.com/Devices } using { /Verse.org/Simulation } spawner_button := class(creative_device): @editable Button:button_device = button_device{} # Kontener do przechowywania subskrypcji zdarzenia var ButtonSubscription:?cancelable = false OnBegin<override>()<suspends>:void= ButtonSubscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith) # Ustaw wynik możliwy do anulowania jako wartość w zmiennej opcji. set ButtonSubscription = option{Subscription} Print("Subskrypcja zdarzenia InteractedWithEvent przycisku i przypisano subskrypcję do ButtonSubscription!") OnButtonInteractedWith(InPlayer:agent):void= Print("Gracz wszedł w interakcję z przyciskiem!") # Dostęp do zmiennej możliwej do anulowania dla subskrypcji InteractedWithEvent if(CancelableResult := ButtonSubscription?): CancelableResult.Cancel() Print("Anulowano to InteractedWithEvent")

Jeśli urządzenie Verse ma wiele subskrypcji zdarzeń, dobrym pomysłem jest użycie kontenera takiego jak tablica do przechowywania wszystkich cancelable wyników z każdej subskrypcji zdarzeń, aby można było je później anulować. Subscribe() zwraca wynik cancelable, więc możesz ustawić wartości tablicy cancelable, gdy pierwszy raz subskrybujesz zdarzenia.

Przykład spawnowania przedmiotu po naciśnięciu przycisku przez gracza

W tej sekcji dowiesz się, jak utworzyć generator przedmiotów, który tworzy przedmiot, gdy gracz wejdzie w interakcję z przyciskiem.

1. Zacznij od rozstawienia na swoim poziomie urządzenia generatora przedmiotów i urządzenia przycisku w swoim poziomie. Informacje o tym, jak rozstawiać urządzenia na swoim poziomie, znajdziesz w sekcji Rozstawianie obiektów w artykule Elementy sterujące UEFN dla użytkowników trybu kreatywnego.
2. Ustaw, jaki przedmiot będzie spawnowany dla urządzenia generatora przedmiotów. Aby dowiedzieć się więcej, patrz generator przedmiotów.
3. Utwórz urządzenie Verse z edytowalnymi właściwościami dla urządzenia przycisku i generatora przedmiotów. Patrz Dodawanie odwołania Verse do urządzenia Trybu kreatywnego w poziomie.
4. Dodaj zmienną opcji cancelable do urządzenia, aby śledzić subskrypcję urządzenia Przycisk.
5. Zasubskrybuj zdarzenie InteractedWithEvent, przenieś wynik na option i przypisz go do zmiennej ButtonSubscription.
6. W procedurze obsługi zdarzeń dla InteractedWithEvent, wywołaj ItemSpawner.SpawnItem(). Następnie anuluj subskrypcję, uzyskując dostęp do wartości wewnątrz opcji ButtonSubscription i wywołując Cancel().
7. Poniżej znajduje się pełny kod Verse dla spawnowania przedmiotu, gdy gracz wchodzi w interakcję z urządzeniem przycisku. Interakcja z urządzeniem przycisku po raz drugi nie spowoduje spawnowania kolejnego przedmiotu.

    using { /Fortnite.com/Devices }
    using { /Verse.org/Simulation }
   
    spawner_button := class(creative_device):
   
       @editable
       Button:button_device = button_device{}
   
       @editable
       ItemSpawner:item_spawner_device = item_spawner_device{}
   
       # Kontener do przechowywania subskrypcji zdarzenia
       var ButtonSubscription:?cancelable = false
   
       OnBegin<override>()<suspends>:void=
   
           Subscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith)
   
           # Dodaj możliwy do anulowania wynik do miejsca w tablicy subskrypcji.
           set ButtonSubscription = option{Subscription}
           Print("Subskrypcja zdarzenia InteractedWithEvent przycisku i przypisano subskrypcję do ButtonSubscription!")
   
       OnButtonInteractedWith(InPlayer:agent):void=
           ItemSpawner.SpawnItem()
   
           # Dostęp do zmiennej możliwej do anulowania dla subskrypcji InteractedWithEvent
           if(CancelableResult := ButtonSubscription?):
               CancelableResult.Cancel()
               Print("Anulowano to InteractedWithEvent")
   Copy full snippet

   using { /Fortnite.com/Devices } using { /Verse.org/Simulation } spawner_button := class(creative_device): @editable Button:button_device = button_device{} @editable ItemSpawner:item_spawner_device = item_spawner_device{} # Kontener do przechowywania subskrypcji zdarzenia var ButtonSubscription:?cancelable = false OnBegin<override>()<suspends>:void= Subscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith) # Dodaj możliwy do anulowania wynik do miejsca w tablicy subskrypcji. set ButtonSubscription = option{Subscription} Print("Subskrypcja zdarzenia InteractedWithEvent przycisku i przypisano subskrypcję do ButtonSubscription!") OnButtonInteractedWith(InPlayer:agent):void= ItemSpawner.SpawnItem() # Dostęp do zmiennej możliwej do anulowania dla subskrypcji InteractedWithEvent if(CancelableResult := ButtonSubscription?): CancelableResult.Cancel() Print("Anulowano to InteractedWithEvent")

   Rozpocznij grę i wejdź w interakcję z przyciskiem, aby wygenerować przedmiot. Ponieważ anulowano InteractedWithEvent, przycisk powinien zespawnować przedmiot tylko raz.

Zapoznaj się z samouczkiem łamigłówki z otagowanymi światłami, aby dowiedzieć się więcej o przykładowej grze wykorzystującej subskrypcję i anulowanie urządzenia!

Oczekiwanie na zdarzenie urządzenia trybu kreatywnego

Możesz subskrybować zdarzenia, ale istnieje inny sposób oczekiwania na ich wystąpienie. Możesz wywołać Await() na zdarzeniu urządzenia trybu kreatywnego, które jest wywołaniem funkcji asynchronicznej i może zająć trochę czasu. Oznacza to, że należy go używać w kontekście asynchronicznym, takim jak wyrażenie współbieżności lub funkcja ze specyfikatorem suspends. Aby dowiedzieć się więcej o współbieżności, sprawdź Przepływ czasu i współbieżność.

W poniższym przykładzie urządzenie Verse czeka na interakcję gracza z urządzeniem aktywatora, zanim wydarzy się cokolwiek innego. Jeśli wejdzie w interakcję z którymkolwiek z urządzeń przycisku przed urządzeniem aktywatora, nic się nie stanie. Po interakcji gracza z urządzeniem aktywatora, gracz musi dokonać wyboru i wybrać pomiędzy dwoma przyciskami. Może wejść w interakcję tylko z jednym z przycisków i tylko raz, aby coś się wydarzyło, ponieważ kod używa wyrażenia race, aby ścigać się między dwoma zdarzeniami przycisku. Więcej szczegółów na temat działania tego wyrażenia współbieżności można znaleźć w race.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

make_a_choice_device:= class(creative_device):

    @editable
    MakeChoice:trigger_device = trigger_device{}

    @editable
    RedButton:button_device = button_device{}

    @editable
    BlueButton:button_device = button_device{}

    OnBegin<override>()<suspends>:void=
        # Ta funkcja czeka, aż gracz nadepnie na aktywator i uniemożliwia wykonanie jakiegokolwiek innego kodu w tym miejscu, dopóki to się nie stanie.
        # Oznacza to, że jeśli gracz wejdzie w interakcję z dwoma przyciskami, nic się nie stanie, dopóki nie wystąpi to zdarzenie.
        MakeChoice.TriggeredEvent.Await()
        Print("Dokonaj wyboru: czerwony przycisk i zostań w krainie czarów lub niebieski przycisk i obudź się z powrotem w swoim łóżku.")

        # W tym wyrażeniu race oba wyrażenia block są wykonywane w tym samym czasie.
        # Gdy gracz wejdzie w interakcję z jednym z przycisków, oczekiwanie na interakcję z drugim przyciskiem zostanie anulowane.
        # Oznacza to, że gracz może wchodzić w interakcje tylko z jednym z przycisków.
        race:
            block:
                RedButton.InteractedWithEvent.Await()
                Print("Wybrano pozostanie w krainie czarów.")
            block:
                BlueButton.InteractedWithEvent.Await()
                Print("Wybrano obudzenie się we własnym łóżku.")

         # Jeśli gracz wejdzie w interakcję z którymkolwiek z urządzeń w tym momencie, nic się nie stanie, ponieważ czekaliśmy tylko raz na wystąpienie zdarzeń.
Copy full snippet

using { /Fortnite.com/Devices } using { /Verse.org/Simulation } make_a_choice_device:= class(creative_device): @editable MakeChoice:trigger_device = trigger_device{} @editable RedButton:button_device = button_device{} @editable BlueButton:button_device = button_device{} OnBegin<override>()<suspends>:void= # Ta funkcja czeka, aż gracz nadepnie na aktywator i uniemożliwia wykonanie jakiegokolwiek innego kodu w tym miejscu, dopóki to się nie stanie. # Oznacza to, że jeśli gracz wejdzie w interakcję z dwoma przyciskami, nic się nie stanie, dopóki nie wystąpi to zdarzenie. MakeChoice.TriggeredEvent.Await() Print("Dokonaj wyboru: czerwony przycisk i zostań w krainie czarów lub niebieski przycisk i obudź się z powrotem w swoim łóżku.") # W tym wyrażeniu race oba wyrażenia block są wykonywane w tym samym czasie. # Gdy gracz wejdzie w interakcję z jednym z przycisków, oczekiwanie na interakcję z drugim przyciskiem zostanie anulowane. # Oznacza to, że gracz może wchodzić w interakcje tylko z jednym z przycisków. race: block: RedButton.InteractedWithEvent.Await() Print("Wybrano pozostanie w krainie czarów.") block: BlueButton.InteractedWithEvent.Await() Print("Wybrano obudzenie się we własnym łóżku.") # Jeśli gracz wejdzie w interakcję z którymkolwiek z urządzeń w tym momencie, nic się nie stanie, ponieważ czekaliśmy tylko raz na wystąpienie zdarzeń.

Te zdarzenia czekają tylko raz. Jeśli chcesz powtórzyć oczekiwanie na te zdarzenia, możesz użyć wyrażenia loop, aby powtórzyć tę logikę tyle razy, ile chcesz.

Następny krok: moduł Urządzenia

Wiesz już, jak pracować z generatorami przedmiotów i przyciskami, ale istnieją bardziej kreatywne urządzenia, których możesz używać i które możesz subskrybować z własnego urządzenia. Informacje te znajdziesz w sekcji Odwołania do interfejsu API w Verse. Przejdź do modułu Urządzenia, aby zobaczyć wszystkie kreatywne urządzenia, z którymi możesz pracować w Verse.