Constantes et variables

Constantes

Une constante est un emplacement où une valeur est stockée, et sa valeur ne peut pas changer pendant l'exécution du programme.

Pour créer une constante, vous devez spécifier son identificateur et son type, c'est-à-dire déclarer une constante, et fournir une valeur pour la constante, c'est-à-dire initialiser une constante.

Une constante doit être initialisée lorsqu'elle est déclarée, et doit être déclarée avant de pouvoir être utilisée.

La création d'une constante utilise la syntaxe suivante :

Identifier : type = expression

Les constantes déclarées dans une fonction peuvent omettre le type :

Identifier := expression

Si le type est omis, le type de la constante est inféré de l'expression utilisée pour initialiser la constante. Seules les constantes locales peuvent omettre le type, car le type décrit comment la constante peut être utilisée. Une constante dans un module fait partie de l'interface du module qui la contient. Sans le type, cette interface n'est pas évidente.

Dans l'exemple suivant, un nombre aléatoire est généré à chaque itération de la boucle et utilisé pour initialiser la constante RandomNumber. Le nombre aléatoire ne sortira de la boucle que s'il est inférieur à vingt.

loop:
    Limit := 20 
    # For local constants, the type can be omitted.
    RandomNumber : int = GetRandomNumber() 
    # Providing the type explicitly can make the code easier to read.
    if (RandomNumber < Limit):
        break

Notez qu'à chaque itération de la boucle, une nouvelle constante nommée RandomNumber est introduite et se voit attribuer le résultat de GetRandomNumber() comme valeur.

Variables

En plus des constantes décrites ci-dessus, Verse possède également des variables.

Les variables sont semblables aux constantes, mais sont définies avec le mot-clé var, ce qui signifie que vous pouvez changer leurs valeurs à tout moment.

Par exemple :

var MaxHealthUpgrade : int = 10

est une variable d'entier, et sa valeur ne peut pas toujours être 10.

La création de variables a la syntaxe suivante :

var Identifier : type = expression

Notez que le type doit être explicitement spécifié pour les variables.

Après avoir créé une variable, vous pouvez lui attribuer une valeur différente à l'aide de la syntaxe suivante :

set Identifier = expression

En dehors de =, divers autres opérateurs peuvent être utilisés pour muter une variable. Par exemple :

var X:int = 0
set X += 1
set X *= 2

Variables globales

Une variable définie dans un module est globale pour toute instance de jeu en cours d'exécution dont la variable se trouve dans l'étendue.

Une façon de déclarer une variable à étendue de module dans Verse est d'utiliser le type weak_map(session, t), le type de clé étant le type de l'instance actuelle de l'île Fortnite, ou la session, et le type de valeur est tout type t. Pour en savoir plus sur weak_map, consultez la rubrique mappage.

L'exemple suivant montre comment créer une variable d'entier globale nommée GlobalInt, incrémentée à chaque appel d'ExampleFunction().

using { /Verse.org/Simulation } # For session

var GlobalInt:weak_map(session, int) = map{}

ExampleFunction():void=
    X := if (Y := GlobalInt[GetSession()]) then Y + 1 else 0
    if:
        set GlobalInt[GetSession()] = X
    Print("{X}")

Les variables à étendue de module utilisant le type de session comme clé présentent les limitations suivantes :

• Vous ne pouvez accéder qu'aux valeurs de la session en cours, à l'exclusion de toute autre session.

• La variable weak_map à étendue de module ne peut pas être complètement lue ou écrite, il n'est donc pas possible de lire ou de remplacer les valeurs pour toutes les sessions.

• Vous ne pouvez pas itérer sur les valeurs d'une weak_map ni savoir combien de sessions sont actuellement actives, car une weak_map n'a pas de durée.

Données persistables

À l'exception des variables à étendue de module associées à la session, une variable à étendue de module requiert une persistance, le stockage de données au-delà de la partie en cours.

Vous pouvez déclarer une variable persistable dans Verse en utilisant le type weak_map(player, t). Tout type persistable représenté par t peut être stocké et accessible pour un joueur particulier, et les données peuvent être visibles lors des sessions de jeu suivantes. Chaque fois qu'un joueur rejoint une partie, ses données enregistrées sont chargées dans toutes les variables à étendue de module de type weak_map(player, t).

Dans l'exemple suivant, la variable globale "weak_map" MySavedPlayerData utilise le type de joueur comme clé et un entier comme valeur. Une fois que vous avez défini vos données persistables, vous devez initialiser les données pour chaque joueur. Pour cela, vérifiez qu'aucune donnée n'est déjà stockée pour ce joueur, puis ajoutez le joueur et une valeur initiale à la weak_map.

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

var MySavedPlayerData:weak_map(player, int) = map{}

# A Verse-authored creative device that can be placed in a level
persistence_example := class(creative_device):

    # Runs when the device is started in a running game

Les variables à étendue de module utilisant le type de joueur comme clé présentent les limitations suivantes :

• L'accès aux données persistantes du joueur n'est autorisé que lorsque le joueur se trouve dans la partie en cours.

• Si un joueur quitte une partie ou ne se trouve pas dans la session en cours, vous ne pouvez plus stocker ses données ni y accéder pendant cette session de jeu. Si le joueur revient au même jeu ou y rejoue, vous pouvez alors accéder à ses données et les mettre à jour.

• Il est impossible de lire ou d'écrire complètement sur la weak_map à portée du module. Il n'est donc pas possible de lire ou de remplacer les valeurs pour tous les joueurs.

• Vous ne pouvez pas itérer sur les valeurs d'une weak_map ni savoir combien de joueurs ont des données associées dans la weak_map, car une weak_map n'a pas de longueur.

• Une île peut avoir jusqu'à deux variables persistables, c'est-à-dire deux variables weak_map dont player est le type clé.

• La valeur weak_map d'au moins une variable persistante doit être une classe si la limite max de variables persistantes a été atteinte.

  • Un enregistrement de weak_map est limité à une taille de données maximale de 128 kilo-octets (Ko) par joueur.

Pour en savoir plus sur la persistance dans Verse, consultez la rubrique Utiliser des données persistantes dans Verse.