1. Epic GamesDeveloper
  3. 3. Como encontrar as luzes em tempo de execução com tags de jogabilidade

3. Como encontrar as luzes em tempo de execução com tags de jogabilidade

Crie um quebra-cabeça em que o jogador deve encontrar a combinação certa de luzes acesas e apagadas para gerar um item, usando um dispositivo criado com Verse.

3. Como encontrar as luzes em tempo de execução com tags de jogabilidade
Prerequisite topics

In order to understand and use the content on this page, make sure you are familiar with the following topics:

Ao concluir esta etapa do tutorial Quebra-cabeça de luzes marcadas, você aprenderá a usar Tags de jogabilidade para encontrar atores marcados com uma tag específica enquanto o jogo está em execução. Tags de jogabilidade permitem trabalhar com vários dispositivos sem precisar configurar suas referências no editor. Isso pode abrir oportunidades de jogabilidade interessantes em que, por exemplo, seu código muda dinamicamente quais dispositivos estão ativos conforme o jogador avança no jogo.

Siga estas etapas para criar uma nova Tag de jogabilidade e atribuí-la a todas as luzes no nível do enigma:

  1. Abra o Explorador do Verse e clique duas vezes em tagged_lights_puzzle.verse para abrir o script no Visual Studio Code.
  2. No topo do arquivo de código:
    • Adicione using { /Verse.org/Simulation/Tags } para fazer referência à classe tag e use a função GetCreativeObjectsWithTag().

    • Adicione using { /Verse.org/Simulation } para tornar as propriedades editáveis.

      ~~~(verse) using { /Fortnite.com/Devices } using { /Verse.org/Native } using { /UnrealEngine.com/Temporary/Diagnostics } using { /Verse.org/Simulation/Tags } using { /Verse.org/Simulation }

    log_tagged_lights_puzzle := class(log_channel){} ~~~

  3. Acima da classe log_tagged_lights_puzzle, adicione uma nova subclasse chamada puzzle_light que herda da classe tag. O nome da classe herdada torna-se uma Tag de jogabilidade personalizada para você usar em qualquer dispositivo do Modo Criativo.

    ~~~(verse) # Derive da classe tag no módulo Verse.org/Simulation/Tags para criar uma nova tag de jogabilidade. puzzle_light := class(tag){}

    log_tagged_lights_puzzle := class(log_channel){} ~~~

  4. Na barra de ferramentas do UEFN, clique em Compilar scripts do Verse para compilar seu código e sua nova tag de jogabilidade puzzle_light para seu projeto.
  5. No Outliner do UEFN, selecione um Dispositivo de Luz Personalizável para abrir seu painel Detalhes.
  6. No painel Detalhes:
    1. Clique em Adicionar novo componente e escolha VerseTagMarkup.
    2. Selecione o componente VerseTagMarkup para visualizar suas configurações no painel Detalhes.
    3. Em Tags de jogabilidade, edite a propriedade Tags e adicione a tag puzzle_light.
    Add VerseTagMarkup Component and add the tag puzzle_light

    Várias tags podem ser adicionadas ao mesmo dispositivo e, portanto, cada dispositivo pode pertencer a vários grupos ao mesmo tempo. Por exemplo, um dispositivo com tag1 e tag2 será encontrado ao chamar GetCreativeObjectsWithTag(tag1{}) ou GetCreativeObjectsWithTag(tag2{}).
  7. Na definição de classe tagged_lights_puzzle, adicione dois campos de matriz variável:
    • Uma matriz variável logic editável chamada LightsState para representar o estado atual de todas as luzes (se elas estão apagadas ou acesas). Ela também é usada para definir o estado inicial das luzes e, portanto, seu número de elementos deve corresponder ao número de luzes marcadas com a tag puzzle_light. Neste exemplo, todas as luzes estão apagadas por padrão, então o valor inicial para todas as luzes é false. ~~~(verse) @editable var LightsState : []logic = array{false, false, false, false} ~~~
    • Uma matriz variável editável customizable_light_device chamada Lights para armazenar todos os dispositivos de Luz Personalizável marcados com a tag de jogabilidade puzzle_light. ~~~(verse) @editable var Lights : []customizable_light_device = array{} ~~~

  8. Quando o jogo começa, o dispositivo deve definir as luzes para corresponder à configuração inicial especificada na matriz LightsState e salvar as referências na matriz Lights, para que elas possam ser atualizadas quando o estado do jogo mudar. Esse trabalho será feito em um método chamado SetupPuzzleLights() : void e chamado no método OnBegin(), para que as luzes sejam acesas quando o jogo começar. ~~~(verse) SetupPuzzleLights() : void = Logger.Print("Configurando as luzes do jogo")

    OnBegin() : void = SetupPuzzleLights() ~~~

  9. Em SetupPuzzleLights(), encontre todos os dispositivos com a tag puzzle_light chamando GetCreativeObjectsWithTag(puzzle_light{}) e salve-os em uma matriz chamada TaggedActors. Como TaggedActors é uma matriz constante cujo escopo é local para o método SetupPuzzleLights(), você não precisa especificar explicitamente um tipo para essa matriz, porque o tipo pode ser inferido nesse contexto. ~~~(verse) SetupPuzzleLights() : void = Logger.Print("Configurando as luzes do jogo") TaggedActors := GetCreativeObjectsWithTag(puzzle_light{}) ~~~

    Diferentes chamadas da função GetCreativeObjectsWithTag() podem colocar os dispositivos em diferentes ordens no resultado da matriz, porque não há ordem garantida ao recuperar atores com tags de jogabilidade.
  10. Agora que você coletou todos os dispositivos que possuem a tag puzzle_light, certifique-se de que cada luz corresponda ao estado inicial especificado pela matriz LightsState. Você pode usar um loop for para percorrer todos os dispositivos marcados. ~~~(verse) for: ActorIndex -> TaggedActor : TaggedActors do: TaggedActor ~~~
  11. A função GetCreativeObjectsWithTag() retorna uma matriz do tipo creative_object_interface. Neste exemplo, você vai querer interagir com cada TaggedActor como um customizable_light_device para poder acender ou apagar a luz.
    • Você pode converter uma classe em uma de suas subclasses (processo chamado de conversão de tipo) usando a sintaxe NewDeviceReference := device_type_to_cast_to[DeviceReference], em que device_type_to_cast_to é o tipo de dispositivo desejado, neste exemplo, customizable_light_device. Esta é uma expressão falível porque a conversão de tipo falhará se o dispositivo não puder ser convertido naquele tipo (por exemplo, se for um tipo de dispositivo diferente). ~~~(verse) LightDevice := customizable_light_device[TaggedActor] ~~~

    A função GetCreativeObjectsWithTag() tem o tipo de retorno []creative_object_interface porque a função pode retornar diferentes tipos de atores, então seu tipo de retorno é a interface que todos os atores devem implementar para serem retornados por GetCreativeObjectsWithTag(). Consulte Tags de jogabilidade para saber mais.
    • Com expressões for, você pode usar expressões falíveis como um filtro e criar novas variáveis que podem ser usadas no bloco de código for. Nesse caso, adicione a conversão de tipo a customizable_light_device da etapa anterior para a expressão de iteração. ~~~(verse) for: ActorIndex -> TaggedActor : TaggedActors LightDevice := customizable_light_device[TaggedActor] do: LightDevice ~~~
    • A última expressão em um bloco de código é o resultado desse bloco de código. A expressão for retorna o resultado do bloco de código de cada iteração em uma matriz, portanto, o resultado dessa expressão for é uma matriz de referências customize_light_device que foram marcadas com puzzle_light. Isso significa que você pode atualizar a matriz Lights com o resultado da expressão for diretamente. ~~~(verse) set Lights = for: ActorIndex -> TaggedActor : TaggedActors LightDevice := customizable_light_device[TaggedActor] do: LightDevice ~~~
    • Esse loop for também deve chamar TurnOn() / TurnOff() nas luzes para corresponder à configuração inicial LightsState no editor. A expressão for pode retornar o índice usado para obter o dispositivo marcado atual (ActorIndex no exemplo), que você pode usar para indexar na matriz LightsState para ver se a luz deve estar acesa ou apagada. ~~~(verse) set Lights = for: ActorIndex -> TaggedActor : TaggedActors LightDevice := customizable_light_device[TaggedActor] ShouldLightBeOn:= LightsState[ActorIndex] do: LightDevice ~~~
    • Em seguida, chame TurnOn() / TurnOff() dependendo de ShouldLightBeOn for true / false. Você pode usar uma expressão if para executar diferentes expressões com base em uma condição (especificamente uma expressão falível). Neste caso, a expressão falível pode usar o operador de consulta ? com IsLightOn, que terá sucesso se ShouldLightBeOn for true (portanto, chame TurnOn()) e falhará se ShouldLightBeOn for false (então chame TurnOff()). ~~~(verse) set Lights = for: ActorIndex -> TaggedActor : TaggedActors LightDevice := customizable_light_device[TaggedActor] ShouldLightBeOn := LightsState[ActorIndex] do: if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff() LightDevice ~~~
    • É uma boa ideia também imprimir o índice da luz e seu valor inicial para que você possa verificar se seu código está funcionando conforme o esperado e comparar com o que você vê no nível.
    • Ao usar {} no meio de uma string, a expressão entre {} é avaliada primeiro, e seu valor é adicionado à string. Portanto, você pode usar uma expressão if no meio de uma string para adicionar valores condicionalmente. ~~~(verse) set Lights = for: ActorIndex -> TaggedActor : TaggedActors LightDevice := customizable_light_device[ActorIndex] ShouldLightBeOn := LightsState[ActorIndex] do: Logger.Print("Adicionando luz no índice {ActorIndex} com State:{if (ShouldLightBeOn?) then "On" else "Off"}") if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff() LightDevice ~~~~
  12. Seu método SetupPuzzleLights() agora deve ficar assim: ~~~(verse) SetupPuzzleLights() : void = TaggedActors := GetCreativeObjectsWithTag(puzzle_light{}) <# Para cada dispositivo com a tag puzzle_light, verifique se é um customize_light_device tentando convertê-lo nesse tipo. Se for, obtenha seu LightState inicial para TurnOn() ou TurnOff() LightDevice. Salve todos os customize_light_device marcados na matriz Lights. #> set Lights = for: ActorIndex -> TaggedActor : TaggedActors LightDevice := customizable_light_device[TaggedActor] ShouldLightBeOn := LightsState[ActorIndex] do: Logger.Print("Adicionando luz no índice {ActorIndex} com State:{if (ShouldLightBeOn?) then "On" else "Off"}") if (ShouldLightBeOn?) then LightDevice.TurnOn() else LightDevice.TurnOff() LightDevice ~~~
  13. Salve o script no Visual Studio Code.
  14. Na barra de ferramentas do UEFN, clique em Compilar scripts do Verse para compilar seu código.
  15. Clique em Play na barra de ferramentas do UEFN para testar o nível.

Ao fazer o teste de jogo do seu nível, você deve ver cada luz adicionada à matriz Lights, junto com seu estado inicial, impresso no registro de saída.

Próxima etapa

Na próxima etapa deste tutorial, você aprenderá a acender e apagar um conjunto específico de luzes quando o jogador pressiona os botões.

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page