2. Definizione delle zone di raccolta e di consegna

Una zona è un'area della mappa (rappresentata da un dispositivo) in cui il giocatore può raccogliere o consegnare oggetti. Completando questo passaggio del tutorial Prova a tempo: A caccia di pizza, imparerai a creare queste zone di raccolta e consegna e ad attivarle/disattivarle per il giocatore.

Utilizzo dell'astrazione per la creazione di una classe di zona

L'Astrazione è un principio di programmazione in cui i dettagli non necessari sono nascosti all'utente che non ha bisogno di comprendere le complessità nascoste. L'astrazione descrive ciò che è qualcosa senza conoscerne il funzionamento. Analogamente, non ci serve sapere come funzionano i meccanismi di un distributore automatico per comprare una merendina.

In Prova a tempo: A caccia di pizza, ci sono due tipi di zone: zone di raccolta, che utilizzano il dispositivo Generatore oggetti, e zone di consegna, che utilizzano il dispositivo Area di cattura. Poiché queste zone si comportano allo stesso modo anche se si tratta di dispositivi diversi (cioè entrambi possono essere attivati e disattivati), è possibile creare una classe per astrarre questo comportamento in un oggetto di zona generico che gestisce le interazioni specifiche del dispositivo.

Per creare questa classe zona, attieniti ai seguenti passaggi:

1. Crea un nuovo file di Verse vuoto denominato pickup_delivery_zone.verse e aprilo in Visual Studio Code.

2. Nel file Verse, crea una nuova classe denominata base_zone con lo specificatore public e aggiungi:

   • Una costante creative_object_interface denominata ActivatorDevice con lo specificatore public, per memorizzare il dispositivo utilizzato nella zona.

   • Evento denominato ZoneCompletedEvent che ha lo specificatore public, per segnalare quando il giocatore interagisce con la zona, ad esempio raccogliendo oggetti o consegnandoli.

   • Funzione denominata ActivateZone() che ha il tipo di restituzione void e lo specificatore public, per abilitare il dispositivo utilizzato per la zona.

   • Funzione denominata DeactivateZone() che ha il tipo di restituzione void e lo specificatore public, per disabilitare il dispositivo utilizzato per la zona.

     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)

     Quando una classe e i suoi membri hanno lo specificatore public, sono universalmente accessibili da altro codice. Per maggiori dettagli, vedi Specificatori e attributi.

3. Nella funzione ActivateZone(), verifica se il dispositivo ActivatorDevice è un dispositivo Area di cattura o Generatore oggetti eseguendo il cast di tipo del dispositivo ActivatorDevice nei diversi tipi e chiama la funzione Enable() sul dispositivo convertito. Esegui la stessa operazione con la funzione DeactivateZone(), ma chiama la funzione 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. Crea una funzione denominata WaitForZoneCompleted() che abbia lo specificatore private e suspends. Questa funzione segnala a ZoneCompletedEvent quando si verifica l'evento specifico del dispositivo. Questa configurazione implica che l'altro codice deve solo attendere ZoneCompletedEvent e non preoccuparsi del tipo di evento utilizzato dal dispositivo sottostante.

   Verse

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

   Copy full snippet(4 lines long)

   Questa funzione deve avere l'effetto suspends per poter chiamare DeviceEvent.Await().

5. Aggiorna ActivateZone() con un'espressione spawn che chiama WaitForZoneCompleted() con l’evento appropriato per il giocatore che interagisce con il dispositivo: AgentEntersEvent per il dispositivo Area di cattura e ItemPickedUpEvent per il dispositivo Generatore oggetti. WaitForZoneCompleted si aspetta un parametro option (indicato da ?) di tipo awaitable(agent), quindi possiamo passare qualsiasi tipo che implementi l'interfaccia awaitable, con il suo tipo parametrico uguale ad agent. Sia CaptureArea.AgentEntersEvent che ItemSpawner.ItemPickedUpEvent rispettano questa condizione, quindi possiamo utilizzarli come parametro. Questo è un altro esempio di astrazione.

   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. Aggiungi un altro evento denominato ZoneDeactivatedEvent che abbia lo specificatore protected. Questo evento è necessario per terminare la funzione WaitForZoneCompleted() se la zona viene disattivata prima che il giocatore la completi. Segnala questo evento nella funzione 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. Aggiorna WaitForZoneCompleted() con un'espressione race in modo che la funzione attenda che il giocatore completi la zona o che la zona sia disattivata. Con l'espressione race, la chiamata di funzione asincrona ZoneDeactivatedEvent.Await() e l'espressione block con l'evento del dispositivo e il segnale ZoneCompletedEvent sono eseguiti contemporaneamente, ma l'espressione che non termina per prima è annullata. 

   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. Infine, crea un costruttore per la classe base_zone che inizializza il campo ActivatorDevice. 

   Verse

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

   Copy full snippet(1 line long)

9. Di seguito è riportato il codice completo per la classe 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)

Individuazione delle zone nel runtime con i tag di gameplay

Ora che abbiamo un modo per creare zone e attivarle/disattivarle, aggiungiamo un modo per inizializzare tutte le zone che hai taggato nel livello e come selezionare la prossima da attivare.

Questo esempio mostra come eseguire questa operazione con una classe responsabile della creazione delle zone e della selezione della zona successiva da attivare.

Per creare la classe per la creazione e la selezione delle zone, attieniti ai seguenti passaggi:

1. Crea una nuova classe denominata tagged_zone_selector nel file pickup_delivery_zone.verse. Aggiungi un array variabile per memorizzare tutte le zone del livello. tagged_zone_selector<public> := class: var Zones<protected> : []base_zone = array{}

2. Aggiungi un metodo denominato InitZones() che abbia lo specificatore public e un parametro tag per trovare tutte le zone associate a quel Tag di gameplay e memorizzarle nella cache. 

   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. Aggiungi un metodo denominato SelectNext() che abbia gli specificatori decides e transacts in modo che il metodo trovi un'altra zona o non riesca. Seleziona la zona a indice casuale nell'array utilizzando GetRandomInt(0, Zones.Length - 1) per l'indice.

   Verse

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

   Copy full snippet(2 lines long)

4. Il codice completo del file pickup_delivery_zone.verse ora deve essere visualizzato come segue:

   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)

Test delle zone di raccolta e di consegna

Ora che hai creato due classi, è bene eseguire il test del codice e assicurarti che la selezione delle zone funzioni nel modo previsto.

Segui questi passaggi per aggiornare il file game_coordinator_device.verse:

1. Aggiungi una costante per il selettore della zona di consegna e un array di variabili per i selettori della zona di raccolta a game_coordinator_device. Poiché in seguito il gioco aumenterà il livello di raccolta dopo ogni raccolta di pizza, sarà necessario un tagged_zone_selector per ogni livello di raccolta desiderato nel gioco, quindi l'array PickupZoneSelectors. Ogni selettore di zona contiene tutte le zone di raccolta di un determinato livello. Deve essere una variabile perché la sua configurazione è determinata dal numero di pickup_zone_tag in PickupZoneLevelTags.

2. Utilizza questa configurazione per estendere il numero di livelli di raccolta con modifiche minime al codice: devi solo aggiornare i PickupZoneLevelTag con altri derivanti da pickup_zone_tag , quindi taggare i dispositivi nell'editor. 

   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. Aggiungi un metodo denominato SetupZones() e chiama il metodo in OnBegin():

   • Imposta il metodo in modo che abbia lo specificatore private e un tipo di restituzione void.

   • Inizializza il selettore della zona di consegna con il delivery_zone_tag.

   • Crea i tag di livello della zona di raccolta e inizializza i selettori della zona di raccolta.

     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. Crea un loop in OnBegin() che selezioni la prossima zona di raccolta, la attivi, attenda che il giocatore completi la zona e poi la disattivi.

   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. Salva i file di Verse, compila il codice ed esegui il playtest del livello.

Durante il playtest del livello, uno dei dispositivi Generatore oggetti si attiverà all'inizio del gioco. Dopo aver raccolto l'oggetto, il dispositivo Generatore oggetti si disattiva e si attiva il dispositivo Area di cattura. Ciò continua fino a quando non termini manualmente il gioco.

Step successivo

• 

  3. Creazione del loop di gioco

  Crea un gioco con Verse in cui i giocatori devono raccogliere e consegnare le pizze prima che scada il tempo!