Un módulo de Verse es una unidad atómica de código que puede redistribuirse y depender de él. Puede evolucionar con el tiempo sin romper dependencias. Puedes importar un módulo a tu archivo de Verse para utilizar definiciones de código de otros archivos de Verse.
Un módulo de Verse se especifica mediante la carpeta en la jerarquía de archivos del proyecto, y el nombre del módulo es el nombre de la carpeta. Todos los archivos .verse que se encuentren en la misma carpeta que el archivo forman parte del módulo de Verse, y pueden acceder a las definiciones de los demás archivos de Verse de su módulo sin necesidad de importar explícitamente el módulo.
Un módulo se identifica por su ruta, por ejemplo, /Verse.org/Verse. Las rutas en Verse proporcionan un espacio de nombres global para identificar elementos, y toman prestada la idea de los dominios web. Estas rutas son persistentes, únicas y detectables por cualquier programador de Verse.
Para obtener una lista de los módulos existentes de Verse, consulta la Referencia de la API de Verse.
Miembros de módulo
Puedes crear módulos dentro de un archivo .verse utilizando la siguiente sintaxis:
module1 := module:
...
# Al igual que las clases y las funciones, también se admite la sintaxis de llaves.
module2 := module
{
...
}
Un módulo definido en el archivo de Verse puede contener cualquier cosa que esté incluida en el nivel superior de un archivo .verse. Esto incluye funciones, constantes, diversos tipos y otras definiciones de módulos. Por ejemplo:
module := module:
submodule<public> := module:
submodule_class<public> := class {}
module_class<public> := class{}
Se puede hacer referencia al contenido de un submódulo utilizando el nombre del módulo cualificado con el nombre del módulo base. Por ejemplo, class1 puede hacer referencia fuera de module1 como module1.module2.class1.
Cómo importar definiciones de otros archivos de Verse
Para poder utilizar el contenido de un módulo de Verse, debes importar el módulo por su ruta. Por ejemplo, el siguiente código importa el módulo Random, identificado por la ruta /Verse.org/Random:
using { /Verse.org/Random }
Cuando el módulo Random se importa en el archivo de Verse, puedes utilizar sus definiciones de código, como la función GetRandomInt().
Otros ejemplos de módulos comunes son Devices, Simulation y Diagnostics (todos se importan por defecto cuando creas un nuevo archivo de Verse a través de UEFN).
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
Para importar módulos de otros archivos de Verse, puedes utilizar una ruta local como using { /TuCarpetaVerse/tu_módulo }, o si el archivo está en el mismo directorio, simplemente using { tu_módulo }.
Puedes importar módulos anidados importando los módulos base antes que los módulos submódulo, o utilizando la notación de puntos. Por ejemplo, dados los módulos:
base_module<public> := module:
submodule<public> := module:
submodule_class := class:
...
Si quieres acceder a los miembros de submodule, puedes importarlo mediante base_module antes de submodule, o importando base_module.submodule. Recuerda que importar submodule antes que base_module producirá un error.
# Funciona e importa tanto módulos base como submódulos.
using { base_module }
using { submodule }
# Funciona e importa solo el submódulo.
using { base_module.submodule }
# No funciona.
using { submodule }
using { base_module }
Cuando creas una subcarpeta en un proyecto de Verse, se crea automáticamente un módulo para esa carpeta. Por ejemplo, si base_module se definió en una carpeta module_folder, module_folder debería tener su propio módulo con base_module.
Otra forma de verlo es que la estructura de archivos module_folder/base_module es la misma que la siguiente:
module_folder := module:
base_module := module:
submodule := module:
submodule_class := class:
...
Recuerda que el módulo de module_folder debe importarse antes que base_module.
# Importa la carpeta que contiene base_module y su submódulo.
using { module_folder }
using { base_module }
using { submodule }
Acceso a las definiciones de un módulo
El acceso de un módulo y su contenido desde otros archivos de Verse se establece mediante especificadores de acceso, como public e internal.
El acceso de las definiciones es internal por defecto, lo que significa que solo se pueden descubrir dentro de su propio módulo. Esto también es válido para los módulos introducidos por carpetas en un proyecto.
Como el especificador de acceso predeterminado es internal, no puedes acceder a los miembros del módulo fuera de él sin hacerlos públicos. Por ejemplo:
# Este módulo y sus miembros no son accesibles desde otros archivos de Verse.
private_module := module:
SecretInt:int = 1
...
# No obstante, este módulo, su submódulo y sus miembros sí lo son.
public_module<public> := module:
public_submodule<public> := module:
PublicInt<public>:int = 1
...
Ten en cuenta que tanto el módulo como sus miembros deben ser public para acceder a ellos en un ámbito distinto.