Un module Verse est une unité atomique de code qui peut être redistribuée et qui peut créer une dépendance. Elle peut évoluer au fil du temps sans rompre les dépendances. Vous pouvez importer un module dans votre fichier Verse pour utiliser les définitions de code d'autres fichiers Verse.
Un module Verse est spécifié par le dossier dans la hiérarchie de fichiers du projet, et le nom du module correspond au nom du dossier. Tous les fichiers .verse situés dans le même dossier que le fichier font partie de ce module Verse et peuvent accéder aux définitions des autres fichiers Verse du module sans importer explicitement le module.
Un module est identifié par son chemin, par exemple, /Verse.org/Verse. Les chemins d'accès Verse fournissent un espace de noms global pour identifier les éléments, à l'instar des domaines Web. Ces chemins sont persistants, uniques et peuvent être découverts par n'importe quel programmeur Verse.
Pour obtenir une liste des modules Verse existants, consultez la référence API de Verse.
Membres de module
Vous pouvez créer des modules au sein d'un fichier .verse à l'aide de la syntaxe suivante :
module1 := module:
...
# Comme pour les classes et les fonctions, la syntaxe des parenthèses est également prise en charge
module2 := module
{
...
}
Un module défini dans le fichier Verse peut contenir tout ce que contient le niveau supérieur d'un fichier .verse. Cela comprend des fonctions, des constantes, divers types, ainsi que d'autres définitions de modules. Par exemple :
module := module:
submodule<public> := module:
submodule_class<public> := class {}
module_class<public> := class{}
Il est possible de référencer le contenu d'un sous-module en utilisant le nom du module qualifié avec le nom du module de base. Par exemple, class1 peut être référencée en dehors de module1 sous le nom module1.module2.class1.
Importer des définitions d'autres fichiers Verse
Pour utiliser le contenu d'un module Verse, vous devez importer le module par son chemin d'accès. Par exemple, le code suivant importe le module Random (aléatoire), identifié par le chemin /Verse.org/Random :
using { /Verse.org/Random }
Lorsque le module Random est importé dans votre fichier Verse, vous pouvez utiliser ses définitions de code, notamment la fonction GetRandomInt().
D'autres exemples de modules courants sont les modules Devices, Simulation et Diagnostics, qui sont tous importés par défaut lorsque vous créez un nouveau fichier Verse via l'UEFN.
using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }
using { /UnrealEngine.com/Temporary/Diagnostics }
Pour importer des modules depuis d'autres fichiers Verse, vous pouvez utiliser un chemin local comme using { /YourVerseFolder/your_module } ou, si le fichier se trouve dans le même répertoire, using { your_module }.
Vous pouvez importer des modules imbriqués en important les modules de base avant les sous-modules, ou en utilisant la notation en pointillés. Par exemple, avec les modules :
base_module<public> := module:
submodule<public> := module:
submodule_class := class:
...
Si vous souhaitez accéder à un membre de submodule, vous pouvez l'importer en important base_module avant submodule ou importer base_module.submodule. Notez que l'importation de submodule avant base_module produit une erreur.
# Fonctionne et importe les modules de base et les sous-modules
using { base_module }
using { submodule }
# Fonctionne et importe uniquement le sous-module
using { base_module.submodule }
# Ne fonctionne pas
using { submodule }
using { base_module }
Lorsque vous créez un sous-dossier dans un projet Verse, un module est automatiquement créé pour ce dossier. Par exemple, si base_module est défini dans un dossier module_folder, module_folder possède son propre module qui contient base_module.
En d'autres termes, la structure du fichier module_folder/base_module est identique à la suivante :
module_folder := module:
base_module := module:
submodule := module:
submodule_class := class:
...
Notez que le module module_folder doit être importé avant base_module.
# Importe le dossier contenant base_module et son sous-module
using { module_folder }
using { base_module }
using { submodule }
Accès aux définitions dans un module
L'accès à un module et à son contenu via d'autres fichiers Verse est défini en utilisant des spécificateurs d'accès tels que public et internal.
Par défaut, l'accès aux définitions est internal, ce qui signifie qu'elles ne peuvent être découvertes que dans leur propre module. Il en va de même pour les modules introduits par les dossiers d'un projet.
Dans la mesure où le spécificateur d'accès par défaut est internal, vous ne pouvez pas accéder aux membres du module en dehors du module sans les rendre publics. Par exemple :
# Ce module et ses membres ne sont pas accessibles à partir d'autres fichiers Verse.
private_module := module:
SecretInt:int = 1
...
# Néanmoins, ce module, son sous-module et ses membres le sont.
public_module<public> := module:
public_submodule<public> := module:
PublicInt<public>:int = 1
...
Notez que le module et ses membres doivent être public pour y accéder dans une autre étendue.