Módulos e caminhos em Verse | Fortnite Documentação

Um módulo Verse é uma unidade atômica de código que pode ser redistribuída e dependente, e pode evoluir ao longo do tempo sem desfazer dependências. Você pode importar um módulo para seu arquivo Verse para usar definições de código de outros arquivos Verse.

Um módulo de Verse é especificado pela pasta na hierarquia de arquivos do projeto, e o nome do módulo é o nome da pasta. Todos os arquivos .verse na mesma pasta que o arquivo fazem parte desse módulo de Verse e podem acessar definições de outros arquivos de Verse no módulo sem importar explicitamente o módulo.

Um módulo é identificado por seu caminho; por exemplo, /Verse.org/Verse. Os caminhos em Verse fornecem um "namespace" global para identificar elementos e tomam a ideia de domínios da web. Esses caminhos são persistentes e únicos e podem ser descobertos por qualquer programador de Verse.

Para obter uma lista de módulos de Verse existentes, consulte a Referência da API Verse.

Membros do módulo

Você pode criar módulos em um arquivo .verse usando a seguinte sintaxe:

module1 := module:
    ...

# Semelhante a classes e funções, a sintaxe de colchetes também é aceita
module2 := module
{
    ...
}

Um módulo definido no arquivo Verse pode incluir qualquer elemento contido no nível superior de um arquivo .verse. O que inclui funções, constantes, vários tipos, bem como outras definições de módulo. Por exemplo:

module := module:
    submodule<public> := module:
        submodule_class<public> := class {}
    module_class<public> := class{}

O conteúdo de um submódulo pode ser referenciado usando o nome do módulo qualificado com o nome do módulo base. Por exemplo, class1 pode ser referenciado fora de module1 como module1.module2.class1.

Importando definições de outros arquivos Verse

Para usar o conteúdo de um módulo de Verse, você deve importar o módulo por seu caminho. Por exemplo, o código a seguir importa o módulo Random, identificado pelo caminho /Verse.org/Random:

using { /Verse.org/Random }

Quando o módulo Random é importado para seu arquivo Verse, você pode usar suas definições de código, como a função GetRandomInt().

Outros exemplos de módulos comuns incluem os módulos Devices, Simulation e Diagnostics, todos podem ser importados por padrão quando você cria um novo arquivo Verse por meio do UEFN.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }

Para importar módulos de outros arquivos Verse, você pode usar um caminho local como using { /YourVerseFolder/your_module } ou, se o arquivo estiver no mesmo diretório, simplesmente com using { your_module }.

Você pode importar módulos aninhados importando módulos básicos antes de módulos de submódulos ou usando a notação de pontos. Por exemplo, dados os módulos:

base_module<public> := module:
    submodule<public> := module:
        submodule_class := class:
            ...

Se você deseja acessar membros em submodule, pode importá-lo importando base_module antes de submodule ou importando base_module.submodule. Observe que importar submodule antes de base_module produzirá um erro.

# Funciona e importa o módulo base e os submódulos
using { base_module }
using { submodule }

# Funciona e importa apenas o submódulo
using { base_module.submodule }

# Não funciona
using { submodule }
using { base_module }

Quando você cria uma subpasta em um projeto de Verse, um módulo é criado automaticamente para essa pasta. Por exemplo, se base_module foi definido em uma pasta module_folder, então module_folder teria seu próprio módulo que contém base_module.

Outra maneira de ver isso é que a estrutura do arquivo module_folder/base_module é a mesma a seguir:

module_folder := module:
    base_module := module:
        submodule := module:
            submodule_class := class:
                ...

Observe que o módulo para module_folder precisaria ser importado antes de base_module.

# Importar a pasta que contém "base_module" e seu submódulo
using { module_folder }
using { base_module }
using { submodule }

Acesso de definições em um módulo

O acesso de um módulo e seu conteúdo de outros arquivos Verse são definidos usando especificadores de acesso, como public e internal.

Por padrão, o acesso das definições é internal, o que significa que elas só podem ser descobertas em seu próprio módulo. O mesmo é válido para módulos introduzidos por pastas em um projeto.

Como o especificador de acesso padrão é internal, você não pode acessar os membros do módulo fora desse módulo sem torná-los públicos. Por exemplo:

# Esse módulo e seus membros não são acessíveis a partir de outros arquivos Verse.
private_module := module:
    SecretInt:int = 1
    ...

# Porém, este módulo, seu submódulo e seus membros são.
public_module<public> := module:
    public_submodule<public> := module:
        PublicInt<public>:int = 1
        ...

Observe que tanto o módulo quanto seus membros precisam ser do tipo public para acessá-los em um escopo diferente.