2. Definindo as zonas de retirada e entrega

Uma zona é uma área do mapa (representada por um dispositivo) onde o jogador pode pegar ou entregar itens. Ao concluir esta etapa no tutorial Prova de tempo: Em busca da pizza, você aprenderá a criar essas zonas de coleta e entrega e ativá-las/desativá-las para o jogador.

Como usar abstração para criar uma classe de zona

Abstração é um princípio de programação em que detalhes desnecessários são ocultados de um usuário quando o usuário não precisa entender as complexidades ocultas. A abstração descreve o que algo é, sem saber como funciona. Por exemplo, você pode colocar dinheiro em uma máquina de venda automática e receber uma guloseima sem entender como a mecânica funciona.

Em Prova de tempo: Em busca da pizza, existem dois tipos de zonas: zonas de retirada, que usam o dispositivo Gerador de Itens, e zonas de entrega, que usam o dispositivo Área de Captura. Como essas zonas se comportarão da mesma maneira, mesmo sendo dispositivos diferentes — o que significa que tanto podem ser ativadas quanto desativadas — você pode criar uma classe para abstrair esse comportamento em um objeto de zona genérico que manipula as interações específicas do dispositivo.

Siga estas etapas para criar essa classe de zona:

1. Crie um novo arquivo do Verse vazio chamado pickup_delivery_zone.verse e abra-o no Visual Studio Code.

2. No arquivo do Verse, crie uma nova classe chamada base_zone com o especificador public e adicione:

   • Uma constante creative_object_interface chamada ActivatorDevice com o especificador public, para armazenar o dispositivo usado na zona.

   • Um evento chamado ZoneCompletedEvent que tenha o especificador public para sinalizar quando o jogador interage com essa zona, como pegar itens ou entregá-los.

   • Uma função chamada ActivateZone() que tem o tipo de retorno void e o especificador public, para habilitar o dispositivo usado para a zona.

   • Uma função chamada DeactivateZone() que tem o tipo de retorno void e o especificador public, para desabilitar o dispositivo usado para a 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 uma classe e seus membros têm o especificador public, eles são universalmente acessíveis de outro código. Para obter mais detalhes, consulte Especificadores e atributos.

3. Na função ActivateZone(), verifique se o ActivatorDevice é um dispositivo de Área de Captura ou um dispositivo Gerador de Itens, convertendo o tipo de ActivatorDevice nos diferentes tipos e chame a função Enable() no dispositivo convertido. Faça o mesmo com a função DeactivateZone(), agora chamando a função 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. Crie uma função chamada WaitForZoneCompleted() que tenha o especificador private e o especificador suspends. Essa função sinalizará ZoneCompletedEvent quando o evento específico do dispositivo ocorrer. Essa configuração significa que outro código só precisa esperar pelo ZoneCompletedEvent e não deve se importar com o tipo de evento que o dispositivo subjacente usa.

   Verse

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

   Copy full snippet(4 lines long)

   Essa função deve ter o efeito suspends para poder chamar DeviceEvent.Await().

5. Atualize ActivateZone() com uma expressão spawn que chame WaitForZoneCompleted() com o evento de dispositivo apropriado para o jogador que interage com o dispositivo: AgentEntersEvent para o dispositivo Área de Captura e ItemPickedUpEvent para o dispositivo Gerador de Itens. WaitForZoneCompleted espera um parâmetro option (indicado por ?) do tipo awaitable(agent), para que possamos passar qualquer tipo que implemente a interface awaitable, com seu tipo paramétrico igual a agent. Tanto CaptureArea.AgentEntersEvent quanto ItemSpawner.ItemPickedUpEvent respeitam essa condição, então podemos usá-los como parâmetro. Este é outro exemplo de abstração.

   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. Adicione outro evento chamado ZoneDeactivatedEvent que tenha o especificador protected. Esse evento é necessário para encerrar a função WaitForZoneCompleted() se a zona for desativada antes que o jogador a complete. Sinalize esse evento na função 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. Atualize WaitForZoneCompleted() com uma expressão race para que a função espere que o jogador complete a zona ou a zona seja desativada. Com a expressão race, a chamada da função assíncrona ZoneDeactivatedEvent.Await() e a expressão block com o evento do dispositivo e o sinal ZoneCompletedEvent serão executadas ao mesmo tempo, mas a expressão que não terminar primeiro será cancelada. 

   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. Finalmente, crie um construtor para a classe base_zone que inicializará o campo ActivatorDevice. 

   Verse

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

   Copy full snippet(1 line long)

9. A seguir está o código completo da 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)

Como encontrar zonas em tempo de execução com tags de jogabilidade

Agora que você tem uma maneira de criar zonas, ativá-las e desativá-las, vamos adicionar uma forma de inicializar todas as zonas que você marcou no nível e de selecionar a próxima a ser ativada.

Este exemplo mostra como fazer isso com uma classe responsável por criar as zonas e selecionar a próxima zona a ser ativada.

Siga estas etapas para criar a classe de criação e seleção de zonas:

1. Crie uma nova classe chamada tagged_zone_selector no arquivo pickup_delivery_zone.verse. Adicione uma matriz variável para armazenar todas as zonas no nível. tagged_zone_selector<public> := class: var Zones<protected> : []base_zone = array{}

2. Adicione um método chamado InitZones() que tenha o especificador public e um parâmetro tag para encontrar todas as zonas associadas a essa tag de jogabilidade e armazená-las em 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. Adicione um método chamado SelectNext() que tenha os especificadores decides e transacts para que o método encontre outra zona ou falhe. Selecione a zona em um índice aleatório na matriz usando GetRandomInt(0, Zones.Length - 1) para o índice.

   Verse

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

   Copy full snippet(2 lines long)

4. O código completo do arquivo pickup_delivery_zone.verse agora deve ter a seguinte aparência:

   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)

Como testar zonas de retirada e entrega

Agora que você criou duas classes, é uma boa ideia testar seu código e garantir que sua seleção de zona funcione conforme esperado.

Siga estas etapas para atualizar o arquivo game_coordinator_device.verse:

1. Adicione uma constante para o seletor de zona de entrega e uma matriz de variável para os seletores de zona de retirada ao game_coordinator_device. Como o jogo aumentará posteriormente o nível de retirada após cada retirada de pizza, você precisará de um tagged_zone_selector para cada nível de retirada que desejar no jogo, daí a matriz PickupZoneSelectors. Cada seletor de zona contém todas as zonas de retirada de um determinado nível. Ele precisa ser uma variável, pois sua configuração é determinada pelo número de elementos pickup_zone_tag em PickupZoneLevelTags.

2. Use essa configuração para estender o número de níveis de retirada com o mínimo de alterações no código: você só precisa atualizar PickupZoneLevelTags com outros derivados de pickup_zone_tag e, em seguida, marcar os dispositivos no 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. Adicione um método chamado SetupZones() e chame o método em OnBegin ():

   • Defina o método para ter o especificador private e um tipo de retorno void.

   • Inicialize o seletor de zona de entrega com delivery_zone_tag.

   • Crie as etiquetas de nível da zona de retirada e inicialize os seletores da zona de retirada.

     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. Crie um loop em OnBegin() que irá selecionar a próxima zona de retirada, ativá-la, esperar que o jogador complete a zona e, em seguida, desativar a zona.

   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. Salve seus arquivos do Verse, compile seu código e teste seu nível.

Quando você testar seu nível, um dos dispositivos Gerador de Itens será ativado no início do jogo. Depois de retirar o item, o dispositivo Gerador de Itens será desativado, e um dispositivo Área de Captura será ativado. Isso continuará até você terminar o jogo manualmente.

Próxima etapa

• 

  3. Criando o loop de jogo

  Crie um jogo com Verse, em que os jogadores devem pegar e entregar pizzas antes que o tempo acabe!