2. Définir les zones de collecte et de livraison

Une zone est un endroit sur la carte (représenté par un appareil) où le joueur peut collecter ou livrer des objets. Dans cette étape du tutoriel Contre-la-montre : Pizza Pursuit, vous apprendrez à créer ces zones de collecte et de livraison et à les activer/désactiver pour le joueur.

Utiliser l'abstraction pour créer une classe de zone

L'abstraction est un principe de programmation qui consiste à masquer les détails inutiles à l'utilisateur lorsque celui-ci n'a pas besoin de comprendre les complexités. L'abstraction décrit ce qu'est une chose, sans savoir comment elle fonctionne. Par exemple, vous pouvez mettre de l'argent dans un distributeur automatique et en retirer une friandise sans comprendre le fonctionnement de la mécanique.

Dans le jeu Contre-la-montre : Pizza Pursuit, il existe deux types de zones : les zones de collecte, qui font appel à l'appareil Générateur d'objets, et les zones de livraison, qui font appel à l'appareil Zone de capture. Dans la mesure où ces zones se comportent de la même manière (c'est-à-dire qu'il est possible de les activer et de les désactiver) bien qu'elles recourent à des appareils différents, vous pouvez créer une classe pour abstraire ce comportement dans un objet de zone générique qui gère les interactions spécifiques de l'appareil.

Procédez comme suit pour créer cette classe de zone :

1. Créez un nouveau fichier Verse vide nommé pickup_delivery_zone.verse et ouvrez-le dans Visual Studio Code.

2. Dans le fichier Verse, créez une nouvelle classe nommée base_zone avec le spécificateur public et ajoutez ce qui suit :

   • Une constante creative_object_interface nommée ActivatorDevice avec le spécificateur public, pour stocker l'appareil utilisé dans la zone.

   • Un événement nommé ZoneCompletedEvent avec le spécificateur public, pour signaler quand le joueur interagit avec cette zone, par exemple en collectant des objets ou en les livrant.

   • Une fonction nommée ActivateZone() avec le type de retour void et le spécificateur public, pour activer l'appareil utilisé pour la zone.

   • Une fonction nommée DeactivateZone() avec le type de retour void et le spécificateur public, pour désactiver l'appareil utilisé pour la zone.

     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)

     Lorsqu'une classe et ses membres ont le spécificateur public, ils sont universellement accessibles depuis d'autres codes. Pour en savoir plus, consultez la rubrique Spécificateurs et attributs.

3. Dans la fonction ActivateZone(), vérifiez si l'appareil ActivatorDevice est un appareil Zone de capture ou un appareil Générateur d'objets en convertissant l'appareil ActivatorDevice en différents types et en appelant la fonction Enable() sur l'appareil converti. Procédez de la même façon avec la fonction DeactivateZone(), mais en appelant la fonction 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. Créez une fonction nommée WaitForZoneCompleted() avec les spécificateurs private et suspends. Cette fonction signale l'événement ZoneCompletedEvent lorsque l'événement propre à l'appareil se produit. Cela signifie que les autres codes doivent se contenter d'attendre ZoneCompletedEvent sans se soucier du type d'événement que l'appareil sous-jacent utilise.

   Verse

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

   Copy full snippet(4 lines long)

   Cette fonction doit avoir l'effet suspends pour pouvoir appeler DeviceEvent.Await().

5. Mettez à jour ActivateZone() avec une expression spawn qui appelle WaitForZoneCompleted() avec l'événement approprié pour le joueur interagissant avec l'appareil : AgentEntersEvent pour la zone de capture et ItemPickedUpEvent pour le générateur d'objets. WaitForZoneCompleted attend un paramètre option (indiqué par ?) de type awaitable(agent) ; vous pouvez transmettre n'importe quel type qui implémente l'interface awaitable, avec son type paramétrique égal à agent. Tant CaptureArea.AgentEntersEvent que ItemSpawner.ItemPickedUpEvent respectent cette condition. Il est donc possible de les utiliser comme paramètre. Voici un autre exemple d'abstraction.

   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. Ajoutez un autre événement nommé ZoneDeactivatedEvent avec le spécificateur protected. Cet événement est nécessaire pour mettre fin à la fonction WaitForZoneCompleted() si la zone est désactivée avant que le joueur l'ait terminée. Signalez cet événement dans la fonction 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. Mettez à jour WaitForZoneCompleted() avec une expression race pour que la fonction attende soit que le joueur termine la zone, soit que la zone soit désactivée. Avec l'expression race, l'appel de fonction asynchrone ZoneDeactivatedEvent.Await() et l'expression block avec l'événement d'appareil et le signal ZoneCompletedEvent s'exécutent simultanément, mais l'expression qui ne se termine pas en premier est annulée. 

   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. Enfin, créez un constructeur pour la classe base_zone qui initialisera le champ ActivatorDevice. 

   Verse

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

   Copy full snippet(1 line long)

9. Voici le code complet de 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)

Rechercher des zones au moment de l'exécution avec des étiquettes de jeu

Maintenant que vous savez comment créer des zones et les activer/désactiver, découvrez comment initialiser toutes les zones que vous avez étiquetées dans le niveau et comment sélectionner la prochaine zone à activer.

Dans cet exemple, nous vous expliquons comment y parvenir avec une classe chargée de créer des zones et de sélectionner la prochaine zone à activer.

Procédez comme suit pour créer la classe permettant de créer et de sélectionner des zones :

1. Créez une nouvelle classe nommée tagged_zone_selector dans le fichier pickup_delivery_zone.verse. Ajoutez une matrice de variable pour stocker toutes les zones du niveau. tagged_zone_selector<public> := class: var Zones<protected> : []base_zone = array{}

2. Ajoutez une méthode nommée InitZones() avec le spécificateur public et un paramètre tag pour rechercher toutes les zones associées à cette étiquette de jeu et les mettre en 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. Ajoutez une méthode nommée SelectNext() avec les spécificateurs decides et transacts afin que la méthode recherche une autre zone ou échoue. Sélectionnez la zone à un index aléatoire dans la matrice en utilisant GetRandomInt(0, Zones.Length - 1) pour l'index.

   Verse

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

   Copy full snippet(2 lines long)

4. Le code complet du fichier pickup_delivery_zone.verse doit maintenant être similaire à celui-ci :

   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)

Tester les zones de collecte et de livraison

Maintenant que vous avez créé deux classes, nous vous conseillons de tester votre code et de vous assurer que votre sélection de zone fonctionne comme prévu.

Procédez comme suit pour mettre à jour votre fichier game_coordinator_device.verse :

1. Ajoutez une constante pour le sélecteur de zone de livraison et une matrice de variable pour les sélecteurs de zone de collecte à l'appareil game_coordinator_device. Dans la mesure où le jeu augmente le niveau de collecte après chaque collecte de pizza, vous devez disposer d'un sélecteur tagged_zone_selector pour chaque niveau de collecte que vous souhaitez intégrer au jeu, d'où la matrice PickupZoneSelectors. Chaque sélecteur de zone contient toutes les zones de collecte d'un certain niveau. Il doit s'agit d'une variable, car sa configuration est déterminée par le nombre de balises pickup_zone_tag dans PickupZoneLevelTags.

2. Utilisez cette configuration pour augmenter le nombre de niveaux de collecte avec un minimum de modifications du code : il vous suffit en effet de mettre à jour les balises PickupZoneLevelTags avec les autres balises dérivées de pickup_zone_tag, puis de baliser les appareils dans l'éditeur. 

   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. Ajoutez une méthode nommée SetupZones() et appelez la méthode dans OnBegin() :

   • Définissez la méthode pour obtenir le spécificateur private et un type de retour void.

   • Initialisez le sélecteur de zone de livraison avec delivery_zone_tag.

   • Créez les balises de niveau de zone de collecte et initialisez les sélecteurs de zone de collecte.

     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. Créez une boucle dans OnBegin() qui sélectionne la prochaine zone de collecte, l'active, attend que le joueur termine la zone, puis désactive la zone.

   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. Enregistrez vos fichiers Verse, compilez votre code et testez votre niveau.

Lorsque vous testez votre niveau, l'un des générateurs d'objets est activé au début du jeu. Après avoir collecté l'objet, le générateur d'objets est désactivé et un appareil de capture de zone est activé. Cette séquence se poursuit jusqu'à ce que vous mettiez fin manuellement à la partie.

Étape suivante

• 

  3. Créer la boucle de jeu

  Créez un jeu avec Verse dans lequel les joueurs doivent collecter et livrer des pizzas avant la fin du compte à rebours.