2. Definiowanie stref odbioru i dostarczania

Strefa jest obszarem mapy (reprezentowanym przez urządzenie), gdzie gracz może odbierać lub dostarczać przedmioty. Wykonując ten krok w samouczku Próba czasu: Pogoń za pizzą (Time Trial: Pizza Pursuit), nauczysz się tworzyć takie strefy odbioru i dostarczania, a także aktywować/dezaktywować je dla gracza.

Tworzenie klasy stref za pomocą abstrakcji

Abstrakcja to zasada programowania, zgodnie z którą niepotrzebne szczegóły są ukrywane przed użytkownikiem, który nie musi rozumieć ukrytych zawiłości. Abstrakcja opisuje, czym coś jest, bez konieczności zaznajamiania się ze sposobem działania takiej rzeczy. Możesz na przykład wrzucić pieniądze do automatu vendingowego i wyciągnąć z niego przekąskę, nie rozumiejąc, jak działa jego mechanizm.

W grze Próba czasu: Pogoń za pizzą istnieją dwa rodzaje stref: strefy odbioru, które wykorzystują urządzenie generatora przedmiotów, oraz strefy dostarczania, które korzystają z urządzenia strefy punktowanej. Strefy te będą zachowywały się w taki sam sposób pomimo zastosowania różnych urządzeń – co oznacza, że będzie można je aktywować i dezaktywować – dlatego możesz utworzyć klasę, aby wyabstrahować to zachowanie do ogólnego obiektu strefy, który będzie obsługiwał interakcje z konkretnymi urządzeniami.

Aby utworzyć klasę stref, wykonaj następujące instrukcje:

1. Utwórz nowy pusty plik Verse o nazwie pickup_delivery_zone.verse i otwórz go w Visual Studio Code.

2. W pliku Verse utwórz nową klasę o nazwie base_zone zawierającą specyfikator public i dodaj:

   • Stała creative_object_interface o nazwie ActivatorDevice ze specyfikatorem public do przechowywania urządzenia używanego w strefie.

   • Zdarzenie o nazwie ZoneCompletedEvent zawierające specyfikator public, aby zasygnalizować, kiedy gracz wejdzie w interakcję z tą strefą, na przykład przez odebranie lub dostarczenie przedmiotów.

   • Funkcja o nazwie ActivateZone() z typem informacji zwrotnej void oraz specyfikatorem public, aby włączyć urządzenie używane w strefie.

   • Funkcja o nazwie DeactivateZone() z typem informacji zwrotnej void oraz specyfikatorem public, aby wyłączyć urządzenie używane w strefie.

     Verse

     base_zone<public> := class:
                                   ActivatorDevice<public> : creative_object_interface
                                   ZoneCompletedEvent<public> : event(base_zone) = event(base_zone){}
     								
                                   ActivateZone<public>() : void =
          Print("Zone activated")
     								
                                   DeactivateZone<public>() : void =
          Print("Zone deactivated")
     

     Copy full snippet(9 lines long)

     Ustawienie dla klasy i jej elementów członkowskich specyfikatora public oznacza, że są one powszechnie dostępne z poziomu innego kodu. Aby uzyskać więcej informacji, patrz: Specyfikatory i atrybuty.

3. W funkcji ActivateZone() sprawdź, czy urządzenie ActivatorDevice jest strefą punktowaną czy generatorem przedmiotów, rzutując typ ActivatorDevice na inne typy i wywołując funkcję Enable() na konwertowanym urządzeniu. Wykonaj tę samą operację w odwołaniu do funkcji DeactivateZone(), pomijając jednak wywołanie funkcji Disable().

   Verse

        base_zone<public> := class:
            ActivatorDevice<public> : creative_object_interface
   		
            ActivateZone<public>() : void =
                Print("Zone activated")
                if (CaptureArea := capture_area_device[ActivatorDevice]):
                    CaptureArea.Enable()
                else if (ItemSpawner := item_spawner_device[ActivatorDevice]):
                    ItemSpawner.Enable()
   		
   
   Expand code Copy full snippet(16 lines long)

4. Utwórz funkcję o nazwie WaitForZoneCompleted() zawierającą specyfikator private oraz specyfikator suspends. Funkcja ta będzie sygnalizować zdarzenie ZoneCompletedEvent, gdy wystąpi zdarzenie specyficzne dla urządzenia. Taka konfiguracja oznacza, że inny kod musi po prostu poczekać na zdarzenie ZoneCompletedEvent i nie musi uwzględniać rodzaju zdarzenia wykorzystywanego przez podstawowe urządzenie.

   Verse

        WaitForZoneCompleted<private>(ZoneDeviceCompletionEventOpt : ?awaitable(agent))<suspends> : void =
            if (DeviceEvent := ZoneDeviceCompletionEventOpt?):
                DeviceEvent.Await()
                ZoneCompletedEvent.Signal(Self)
   

   Copy full snippet(4 lines long)

   Funkcja ta musi zawierać efekt suspends, aby móc wywołać funkcję DeviceEvent.Await().

5. Zaktualizuj funkcję ActivateZone() o wyrażenie spawn wywołujące funkcję WaitForZoneCompleted() z uwzględnieniem zdarzenia urządzenia odpowiedniego dla gracza wchodzącego w interakcję z urządzeniem: AgentEntersEvent w przypadku strefy punktowanej i ItemPickedUpEvent w przypadku generatora przedmiotów. WaitForZoneCompleted oczekuje parametru option (wskazywanego symbolem ?) typu awaitable(agent), można więc przekazać dowolny typ, który implementuje interfejs awaitable, a jego typ parametryczny jest równy typowi agent. Zarówno zdarzenie CaptureArea.AgentEntersEvent, jak i zdarzenie ItemSpawner.ItemPickedUpEvent spełniają ten warunek, dlatego można ich użyć jako parametru. Oto kolejny przykład abstrakcji.

   Verse

        ActivateZone<public>() : void =
            Print("Zone activated")
            if (CaptureArea := capture_area_device[ActivatorDevice]):
                CaptureArea.Enable()
                spawn { WaitForZoneCompleted(option{CaptureArea.AgentEntersEvent})}
            else if (ItemSpawner := item_spawner_device[ActivatorDevice]):
                ItemSpawner.Enable()
                spawn { WaitForZoneCompleted(option{ItemSpawner.ItemPickedUpEvent}) }
   

   Copy full snippet(8 lines long)

6. Dodaj kolejne zdarzenie o nazwie ZoneDeactivatedEvent zawierające specyfikator protected. Zdarzenie to jest konieczne do zakończenia funkcji WaitForZoneCompleted(), jeśli strefa zostanie dezaktywowana, zanim gracz ją ukończy. Zasygnalizuj to zdarzenie w funkcji DeactivateZone().

   Verse

        ZoneDeactivatedEvent<protected> : event() = event(){}
   		
        DeactivateZone<public>() : void =
            Print("Zone deactivated")
            if (CaptureArea := capture_area_device[ActivatorDevice]):
                CaptureArea.Disable()
            else if (ItemSpawner := item_spawner_device[ActivatorDevice]):
                ItemSpawner.Disable()
            ZoneDeactivatedEvent.Signal()
   

   Copy full snippet(9 lines long)

7. Zaktualizuj WaitForZoneCompleted() o wyrażenie race. Dzięki temu funkcja będzie czekać, aż gracz ukończy strefę lub strefa zostanie zdezaktywowana. Po zastosowaniu wyrażenia race wywołanie funkcji asynchronicznej ZoneDeactivatedEvent.Await() oraz wyrażenie block ze zdarzeniem urządzenia i sygnałem ZoneCompletedEvent są uruchamiane równocześnie, jednak wyrażenie, które nie zostanie zakończone jako pierwsze, będzie anulowane. 

   Verse

   WaitForZoneCompleted<private>(ZoneDeviceCompletionEventOpt : ?awaitable(agent))<suspends> : void = if (DeviceEvent := ZoneDeviceCompletionEventOpt?): race: block: DeviceEvent.Await() ZoneCompletedEvent.Signal(Self) ZoneDeactivatedEvent.Await()

   Copy full snippet(1 line long)

8. Na końcu utwórz konstruktor dla klasy base_zone, który będzie inicjował pole ActivatorDevice. 

   Verse

   MakeBaseZone<constructor><public>(InActivatorDevice : creative_object_interface) := base_zone: ActivatorDevice := InActivatorDevice

   Copy full snippet(1 line long)

9. Poniżej przedstawiono kompletny kod klasy base_zone.

   Verse

        # A zone is an area of the map (represented by a device) that can be Activated/Deactivated and that provides events to signal when the zone has been "Completed" (can't be completed anymore until next activation).
        # Zone "Completed" depends on the device type (ActivatorDevice) for the zone.
        # Suggested usage: ActivateZone() -> ZoneCompletedEvent.Await() -> DeactivateZone() #
   		
        base_zone<public> := class:
            ActivatorDevice<public> : creative_object_interface
            ZoneCompletedEvent<public> : event(base_zone) = event(base_zone){}
   		
            GetTransform<public>() : transform =
                ActivatorDevice.GetTransform()
   
   Expand code Copy full snippet(46 lines long)

Wyszukiwanie stref w czasie wykonywania programu za pomocą tagów rozgrywki

Znasz już sposób tworzenia oraz aktywowania/dezaktywowania stref. Poznajmy więc sposób zainicjowania wszystkich stref w poziomie oznaczonych tagami oraz wybierania kolejnej strefy do aktywowania.

Ten przykład ilustruje, jak należy to zrobić, posługując się klasą odpowiedzialną za tworzenie stref oraz wybieranie kolejnej strefy do aktywowania.

Aby utworzyć klasę do tworzenia i wyboru stref, wykonaj następujące instrukcje:

1. Utwórz nową klasę o nazwie tagged_zone_selector w pliku pickup_delivery_zone.verse. Dodaj tablicę zmiennych, w której zostaną zapisane wszystkie strefy poziomu. tagged_zone_selector<public> := class: var Zones<protected> : []base_zone = array{}

2. Dodaj metodę o nazwie InitZones() zawierającą specyfikator public oraz parametr tag, aby wyszukać wszystkie strefy powiązane z tym tagiem rozgrywki i zapisać je w pamięci podręcznej. 

   Verse

   InitZones<public>(ZoneTag : tag) : void =
    
   # On creation of a zone selector, find all available zones and cache them so we don't consume time searching for tagged devices every time the next zone is selected.
    
   ZoneDevices := GetCreativeObjectsWithTag(ZoneTag) 
   set Zones = 
     for (ZoneDevice : ZoneDevices): MakeBaseZone(ZoneDevice)

   Copy full snippet(7 lines long)

3. Dodaj metodę o nazwie SelectNext() zawierającą specyfikatory decides i transacts, aby metoda albo znalazła kolejną strefę, albo zawiodła. Wybierz strefę pod losowym indeksem w tablicy, stosując dla indeksu zapis GetRandomInt(0, Zones.Length - 1).

   Verse

        SelectNext<public>()<transacts><decides> : base_zone =
            Zones[GetRandomInt(0, Zones.Length - 1)]

   Copy full snippet(2 lines long)

4. Kompletny kod pliku pickup_delivery_zone.verse powinien wyglądać następująco:

   Verse

        using { /Verse.org/Simulation }
        using { /Verse.org/Random }
        using { /Verse.org/Concurrency }
        using { /Verse.org/Simulation/Tags }
        using { /UnrealEngine.com/Temporary/SpatialMath }
        using { /Fortnite.com/Devices }
   
        <# A zone is an area of the map (represented by a device) that can be Activated/Deactivated and that provides events
        to signal when the zone has been "Completed" (can't be completed anymore until next activation).
        Zone "Completed" depends on the device type (ActivatorDevice) for the zone.
   
   Expand code Copy full snippet(68 lines long)

Testowanie stref odbioru i dostarczania

Masz już utworzone dwie klasy. Teraz dobrym pomysłem będzie przetestowanie kodu i upewnienie się, że mechanizm wyboru stref działa w oczekiwany sposób.

Aby zaktualizować swój plik game_coordinator_device.verse, wykonaj następujące instrukcje:

1. Dodaj do urządzenia game_coordinator_device stałą dla wybieracza strefy dostarczania oraz tablicę zmiennych dla selektorów strefy odbioru. Gra będzie później podwyższać poziom odbioru po każdym odebraniu pizzy, dlatego potrzebny będzie jeden tagged_zone_selector dla każdego poziomu odbioru, jaki chcesz uzyskać w grze, stąd tablica PickupZoneSelectors. W każdym wybieraczu strefy znajdują się strefy odbioru konkretnego poziomu. Musi być zmienną, ponieważ jego konfiguracja zależy od liczby tagów pickup_zone_tag w PickupZoneLevelTags.

2. Taka konfiguracja pozwala zwiększyć liczbę poziomów odbioru przy minimalnych zmianach w kodzie: wystarczy zaktualizować PickupZoneLevelTags o dodatkowe poziomy wyprowadzone z tagu pickup_zone_tag, a następnie oznaczyć urządzenia tagami w edytorze. 

   Verse

   game_coordinator_device<public> := class<concrete>(creative_device): DeliveryZoneSelector<private> : tagged_zone_selector = tagged_zone_selector{} 
   var PickupZoneSelectors<private> : []tagged_zone_selector = array{}

   Copy full snippet(2 lines long)

3. Dodaj metodę o nazwie SetupZones() i wywołaj ją w metodzie OnBegin():

   • Ustaw dla metody specyfikator private oraz typ informacji zwrotnej void.

   • Zainicjuj wybieracz strefy dostarczania za pomocą tagu delivery_zone_tag.

   • Utwórz tagi poziomu strefy odbioru i zainicjuj wybieracze strefy odbioru.

     Verse

     OnBegin<override>()<suspends> : void =
        SetupZones()
     								
     SetupZones<private>() : void =
                                   DeliveryZoneSelector.InitZones(delivery_zone_tag{})
     								
                                   PickupZoneLevelTags : []pickup_zone_tag = array{pickup_zone_level_1_tag{}, pickup_zone_level_2_tag{}, pickup_zone_level_3_tag{}}
     								set PickupZoneSelectors = 
     for(PickupZoneTag : PickupZoneLevelTags):
     PickupZone := tagged_zone_selector{}
     
     Expand code Copy full snippet(12 lines long)

4. Utwórz w metodzie OnBegin() pętlę, która będzie wybierać kolejną strefę odbioru, aktywować ją i czekać, aż gracz ukończy strefę, po czym ją dezaktywuje.

   Verse

   OnBegin<override>()<suspends> : void =
   SetupZones()
   		
   var PickupLevel : int = 0
   		
   loop:
      if (PickupZone : base_zone = PickupZoneSelectors[PickupLevel].SelectNext[]):
         PickupZone.ActivateZone()
         PickupZone.ZoneCompletedEvent.Await()
         PickupZone.DeactivateZone()
   
   Expand code Copy full snippet(21 lines long)

5. Zapisz swoje pliki Verse, skompiluj kod i przeprowadź test gry na swoim poziomie.

W trakcie przeprowadzania testu gry na twoim poziomie jeden z generatorów przedmiotów zostanie aktywowany na początku gry. Po odebraniu przedmiotu generator przedmiotów zostanie dezaktywowany i nastąpi aktywacja strefy punktowanej. Cykl ten będzie kontynuowany, dopóki ręcznie nie zakończysz gry.

Następny krok

• 

  3. Tworzenie pętli gry

  Tworzenie gry w języku Verse, w której gracze muszą odebrać i dostarczyć pizzę, zanim upłynie czas!