Glossaire de Verse

Lorsqu'une classe ou une méthode de classe possède le spécificateur abstract, vous ne pouvez pas créer d'instance de la classe. Une classe abstraite est destinée à être utilisée comme super-classe, dont certains membres sont appliqués ou spécifiés, mais pas tous. Aussi appelée classe de base.  

Un principe de programmation où les détails inutiles sont cachés à l'utilisateur lorsque celui-ci n'a pas besoin de comprendre les complexités cachées. Par exemple, vous pouvez mettre de l'argent dans un distributeur automatique et en retirer une friandise sans comprendre le fonctionnement de la mécanique.

Les autorisations nécessaires pour accéder à un membre. Elles sont spécifiées à l'aide d'un spécificateur sur le membre.  

Les spécificateurs d'accès définissent le niveau d'accès. Voici tous les spécificateurs d'accès que vous pouvez utiliser avec les classes :

1. public : accès sans restriction.

2. interne : accès limité au module actuel. Il s'agit de l'accès par défaut.

3. protégé : accès limité à la classe actuelle et à toute sous-classe.

4. privé : accès limité à la classe actuelle.

Un effet additif est un effet qui peut être ajouté à un effet exclusif. Parmi les effets additifs figurent suspends et decides.  

Un agent peut représenter soit un joueur, soit un personnage non-joueur (PNJ).  

Un algorithme est une séquence d'instructions écrite pour résoudre un problème ou accomplir une tâche. Un peu comme la recette d'un plat. Lorsque vous écrivez un code qui résout un problème ou accomplit une tâche, ce code est votre algorithme.

Voir hexadécimal.  

Également connue sous le nom d'analyse sensible au contexte, l'analyse sémantique s'effectue dans le compilateur après avoir réuni les informations sémantiques nécessaires auprès du code source (le code que vous avez rédigé). Elle cherche des erreurs de cohérence sémantique et effectue des vérifications de type, en vérifiant par exemple que chaque opérateur a un opérande ou en s'assurant de la déclaration d'une variable avant son utilisation.

Acronyme anglais d'Application Programming Interface (interface de programmation d'applications), qui désigne des bibliothèques généralement regroupées en ensembles de fonctions, de types et de structures de données pouvant être appelés, qui permettent aux utilisateurs d'accéder aux systèmes de l'Unreal Engine et de Fortnite et d'interagir avec eux.  

Les appareils sont des objets dans Fortnite qui effectuent des tâches spécifiques visant à contrôler le jeu. 

Un appareil, tout comme un accessoire, est quelque chose que vous pouvez placer sur l'île. Mais la différence avec les accessoires, c'est que les appareils servent à créer des interactions avec les joueurs. Différents appareils ont différentes fonctions, mais ils font tous quelque chose.

Considérez un appareil comme un paquet de mécaniques de jeu doté de fonctionnalités spécifiques que vous pouvez personnaliser pour prendre en charge votre jeu. La plupart des appareils peuvent être personnalisés pour faire ce que vous souhaitez qu'ils fassent de la manière qui vous convient. Tous les appareils disposent également de paramètres par défaut, ce qui leur permet de fonctionner sans être personnalisés.

Dans Verse, un appareil est le bloc de construction de base utilisé pour construire les mécaniques du jeu. Un appareil pilote les interactions des joueurs qui contrôlent elles-mêmes le gameplay.

Appareil programmé directement à l'aide de Verse, à utiliser dans l'Unreal Editor pour Fortnite (UEFN).

Un archétype est une instance d'une classe entièrement définie avec des valeurs pour ses champs dans une classe.  

Processus de création d'un archétype. À comparer avec constructeur, qui peut également exécuter une logique ou d'autres fonctions.  

La valeur attribuée à un paramètre dans une signature de fonction mappée à partir d'un appel de fonction.  

Dans Verse, une expression d'assignation stocke une valeur à un emplacement mutable, par exemple lors de l'initialisation d'une variable ou de la modification de la valeur d'une variable.  

Une expression asynchrone a la possibilité de prendre du temps pour évaluer, mais ne doit pas nécessairement le faire. Une expression asynchrone peut se terminer ou non lors de la mise à jour actuelle de la simulation ou lors d'une mise à jour ultérieure. Les fonctions asynchrones identifiées par un spécificateur suspends sont également appelées coroutines. Les expressions asynchrones s'opposent aux expressions immédiates.  

L'étendue pour laquelle une expression asynchrone telle qu'un appel de coroutine est autorisée.

Unité de code unique et complète qui s'exécute complètement ou échoue complètement, sans interruption ni observation d'un autre code. Le code atomique ne peut pas être interrompu. Toutes les expressions immédiates adjacentesnon asynchrones sont considérées comme atomiques : leur code est sûr de s'exécuter sans interruption dans la même mise à jour et sans préemption ni changement de contexte.  

Le système hexadécimal (hexa- signifiant six et décimal dix), en base 16 (souvent abrégé en hex), est un système de numérotation ayant recours à 16 symboles, au lieu des 10 symboles généralement utilisés dans le système en base 10.  

Qui fonctionne dans deux directions.

En programmation, lier consiste à créer une connexion entre au moins deux objets de programmation pendant une durée définie.

Dans Fortnite, "liaison" signifie associer une fonction à un événement. 

Dans Verse, la liaison consiste à créer une connexion entre au moins deux objets de programmation pendant une durée définie.   Par exemple, si vous liez une fonction à l'événement InteractedWithEvent d'un bouton, chaque fois qu'un joueur interagit avec ce bouton, la fonction liée est appelée. Cela peut faire référence à l'association d'une variable à une valeur ou un objet, ou à l'association d'un gestionnaire à un événement.  

Une expression de bloc est un moyen de regrouper des expressions en une seule expression ou d'imbriquer un bloc de code. Les expressions de bloc se comportent de manière semblable aux blocs de code.  

Un bloc avec une étendue propre qui définit les sous-expressions d'un élément de langage, telles qu'un corps de fonction ou un corps de boucle. Par exemple, un corps de fonction contient des expressions qui définissent ce que fait la fonction, et toutes les variablesdéclarées dans la fonction sont locales à ce corps de fonction.  

1. Pour le mode Créatif de Fortnite et l'UEFN, un comportement incorrect ou inattendu d'un programme.

2. Pour Verse, un bogue est une erreur dans un programme informatique entraînant un résultat incorrect ou inattendu. Les bogues se produisent pendant l’exécution, contrairement aux erreurs de compilation, qui se produisent pendant la compilation de Verse. Le processus d’identification et de suppression des bogues est appelé débogage.  

Voir Logique booléenne.  

Un système de logique où la valeur exprimée est soit vraie (true), soit fausse (false), et qui est souvent utilisée pour déterminer le contrôle de flux dans les langages de programmation. Ce système porte le nom de George Boole (1815-1864), un mathématicien qui a apporté une contribution essentielle aux domaines de la logique et de l'algèbre.

Dans Verse, le type utilisé pour représenter ce qui est vrai (true) et faux (false) est logic. Cette logique booléenne est exécutée au moyen d'expressions faillibles dans des contextes d'échec.

1. Pour l'UEFN, voir liaison.

2. Pour Verse, une variable sur laquelle une liaison a été effectuée. Toutes les variables Verse sont liées immédiatement après avoir été définies. Elles ne peuvent pas se trouver dans un état non lié.    

Voir la définition de Crochets.  

Les parenthèses sont utilisées dans Verse pour spécifier différents types d'informations dans le code. Verse utilise quatre ensembles de parenthèses. Parmi leurs utilisations, on trouve, sans toutefois s'y limiter :

1. () Les parenthèses sont utilisées pour définir des paramètres dans une signature de fonction et des arguments dans un appel de fonction, ainsi que pour regrouper des expressions, des tuples et des sous-classes.

2. [] Les crochets (également appelés crochets carrés) sont utilisés pour les appels de fonction faillibles, les spécificateurs de type pour les matrices et les mappages, et l'indexation dans une matrice.

3. {} Les accolades sont utilisées pour l'instanciation d'archétype, la mise en forme des blocs de code et l'interpolation de chaîne.

4. <> Les chevrons sont utilisés pour ajouter des spécificateurs aux identificateurs et aux fonctions.

Une expression de branche démarre un bloc d'une ou plusieurs sous-expressions asynchrones. Toute expression qui suit est exécutée immédiatement.  

Pour en savoir plus, consultez la page Concurrence.  

Une expression qui "sort" de la boucle actuelle et exécute l'expression suivante après celle de la boucle. Pour plus d'informations, consultez Loop et Break.  

Inverser la direction à plusieurs reprises.

Dans certains langages de programmation, un élément intégré est un élément que vous pouvez utiliser directement dans le langage et ses bibliothèques standard.  

  Un type intégré ne peut pas être décomposé davantage, contrairement à un type composite.  

Langage de programmation courant utilisé dans de nombreuses applications, en particulier dans les moteurs de jeu tels que l'Unreal Engine.

Méthode de stockage permettant d'accéder plus rapidement aux données.

Une liste des méthodes dans une pile d'appels, avec des informations sur chaque appel, telles que le temps d'exécution, l'horodatage et l'identificateur de la fonction.  

La pile d'appels est ce qu'un programme utilise pour garder la trace des appels : les fonctions en cours d'exécution, celles qui sont terminées et celles qui sont encore à venir.

Expression qui effectue un appel.  

  Expression qui effectue un appel.  

Une expression de cas peut contrôler le déroulement d'un programme à partir d'une liste d'options. Pour plus d'informations, consultez Case.

1. Carré : une section de grille sur une surface, comme un mur ou un sol.

2. Case : une manière d'organiser visuellement des options.

Pour Verse : une section de grille sur une surface, comme un mur ou un sol.

Opération mathématique qui arrondit une valeur rationnelle à l'entier le plus proche. Comparez cette définition à Floor.

Une façon de suivre les modifications apportées à un fichier dans Perforce entre les fichiers locaux stockés sur votre ordinateur et les fichiers envoyés au serveur et fusionnés avec les fichiers sources du projet. Une liste de modifications est également appelée CL (Change List).

Un type de données qui stocke un caractère unique.

Le codage des caractères est le mappage entre un caractère de texte et des données que l'ordinateur peut comprendre, appelé point de code.

Le CI/CD désigne l'intégration continue et la livraison continue ou le déploiement continu. Le CI/CD fait le lien entre le développement et l'application grâce à l'automatisation de la construction, des tests et du déploiement des applications.

Classe dont d'autres classes sont dérivées. Une classe qui hérite d'une classe de base possède tous les membres et toutes les fonctions membres, et peut avoir des propriétés supplémentaires qui ne sont pas incluses dans la classe de base. Une classe de base est également appelée classe parente ou super-classe.

Le code, parfois appelé code source, est l'ensemble des instructions écrites par un programmeur qui indiquent à un logiciel comment fonctionner. Le code source Verse peut être lu par le programmeur, mais pas par l'ordinateur. Avant que l'ordinateur puisse lire ou exécuter le programme, il doit être converti en instructions exécutables par l'ordinateur, une étape appelée compilation. Lorsqu'un programmeur dit qu'il code, cela signifie qu'il écrit ces instructions.

Un bloc, ou bloc de code, est un groupe d'expressions qui introduit un nouveau corps de code. Vous pouvez également avoir un bloc de code qui ne contient aucune expression, mais il s'agit généralement d'un espace réservé qui sera ultérieurement rempli d'expressions.

Les blocs de code suivent un identificateur.

Un bloc de code peut avoir trois formats différents dans Verse. Tous ces formats sont sémantiquement identiques dans la mesure où le format ne change pas ce que le code fait réellement.

Un format espacé commence le bloc par :, et chaque expression suit sur sa propre ligne avec un retrait de quatre espaces :

if (test-arg-block):
  expression1
  expression2

Notez qu'if (test-arg-block) ne fait pas partie du bloc, mais que le bloc commence, à la fin de cette ligne, avec :. Vous pouvez également utiliser ; pour séparer plusieurs expressions sur une même ligne :

if (test-arg-block):
  expression1; expression2; expression3

Dans un format accolé sur plusieurs lignes, le bloc est entouré de {} (accolades), et les expressions sont sur de nouvelles lignes :

if (test-arg-block)
{
  expression1
  expression2
}

De même que pour le format espacé, vous pouvez également utiliser ; pour séparer plusieurs expressions sur une même ligne.

if (test-arg-block)
{
  expression1; expression2
}

Le troisième format est le format accolé sur une seule ligne. Là encore, le bloc est entouré de {}, mais chaque expression est séparée par ; au lieu d'être placée sur une nouvelle ligne. Notez que vous n'êtes pas obligé de placer les caractères {} sur des lignes séparées.

if (test-arg-block) {expression1; expression2}

Pour en savoir plus, consultez Blocs de code.

Voir commentaire.

Une valeur dans l'espace de code Unicode pour le codage des caractères.

Un programme, un module ou une classe pris indépendamment, qui démontre un ou plusieurs concepts, classes, fonctions ou tout autre aspect d'un langage de programmation. Comparez cette définition à celle du terme extrait de code.

Un extrait de code, souvent court, est généralement destiné à présenter ou à implémenter un concept spécifique.

Les extraits de code ne sont pas des programmes complets et autonomes. Les extraits de code peuvent être copiés-collés dans des blocs de code. Comparez cette définition à celle du terme exemple de code.

La combinaison minimale de bits qui peut représenter une unité de texte codé. UTF-8 utilise 8 bits pour son unité de code.

La conversion d'une valeur en type de données indifférent. Les conversions de type peuvent être effectuées implicitement ou explicitement. Conversion implicite. également appelée forçage, elle est effectuée automatiquement.

Un commentaire écrit par le programmeur qui explique quelque chose sur le code ou la raison pour laquelle le programmeur a programmé quelque chose. Si le code lui-même montre le comment du programme, les commentaires sont généralement ajoutés pour expliquer le pourquoi.

Les commentaires de code peuvent apparaître n'importe où dans le code et commencent par #. Lorsque le programme s'exécute, les commentaires de code sont ignorés.

Vous pouvez commenter une ligne unique en plaçant un # au début de la ligne. Le retour à la fin de la ligne met fin au commentaire.

# A single line is commented this way.

Vous pouvez faire un commentaire en bloc de plusieurs lignes en utilisant <# pour commencer le bloc et #> pour le terminer :

<# You can make multi-line comments
in your code by starting and ending 
the comments as shown here.
#>

Pour découvrir d'autres façons d'ajouter des commentaires à votre code, consultez le Guide de référence rapide du langage Verse.

Les types communs sont des types intégrés et utilisés fréquemment. Parmi les types communs figurent any, comparable, float, int, logic, rational et string.

Dans Verse, les expressions de comparaison consistent à comparer deux choses en utilisant l'un des  opérateurs d'inégalité : <, >, <=, >=, <>.

Lorsque le code source est converti en instructions machine. Comparez cette définition à temps d'exécution.

Convertir des programmes d'un langage lisible par l'homme en instructions exécutables par ordinateur.

Logiciel qui convertit des instructions de programme lisibles par l'homme en instructions exécutables par l'ordinateur, que l'on appelle parfois parser. La période pendant laquelle le compilateur s'exécute est appelée temps de compilation.

Une erreur de compilation est due à la détection de code incorrect par le compilateur Verse pendant le temps de compilation. Comparer avec les bogues, qui se produisent au moment de l'exécution.

L'état d'une tâche exécutée jusqu'à son terme.

1. Tuile autonome pour le rendu d'un bout de terrain. Les composants sont parfois appelés cellules. Voir aussi World Partition.  

2.  Les composants sont ce qui fournit données et comportement aux entités dans Scene Graph. Ils définissent ce qu'une entité est censée faire dans la scène.  

Les composants ont des propriétés modifiables qui peuvent être physiques, comme un maillage statique ou un système de particules, ou logiques, comme une balise de jeu ou du code Verse personnalisé définissant le déplacement d'une plateforme. Par défaut, toutes les entités ont un composant de transformation pour préciser où se situe l'entité dans le monde.

Dans Verse, fonction ou groupe de fonctions connexes dans un programme, qui peuvent être réutilisées.

Un type de données composite, parfois appelé composé ou agrégat, est un type qui peut être composé de champs ou d'éléments (généralement nommés) de types primitifs ou d'autres types composites. Il possède généralement un nombre fixe de champs ou d'éléments pour sa durée de vie. Verse utilise actuellement les types composites suivants : structure, classe, énumération, interface et module.

Cet effet indique qu'une fonction renvoie la même sortie lorsque la même entrée lui est présentée à plusieurs reprises.

Voir concaténation.

La concaténation consiste à ajouter une chaîne à une autre chaîne. Vous pouvez utiliser l'opérateur + pour concaténer des chaînes.

Une classe dotée d'un spécificateur concret permet de construire une instance de la classe avec un archétype vide, ce qui signifie que tous les champs de la classe doivent être définis avec une valeur initiale.

Plusieurs calculs qui s'exécutent dans la même période effective sont simultanés. Il s'agit de mises à jour de simulations logiques, de ticks et d'images qui se chevauchent, même si elles sont potentiellement étalées dans le temps physique, comme sur un seul processeur, et pas nécessairement parallèles.

Une condition est un élément que le programme peut vérifier comme étant vrai ou faux. Une expression conditionnelle peut évaluer la condition et renvoyer un résultat de type vrai (true) ou faux (false).

Une expression qui évalue une condition et exécute des instructions en fonction du résultat de la condition. L'expression if est un exemple d'expression conditionnelle.

Une constante est un emplacement où une valeur est stockée, et sa valeur ne peut pas changer pendant l'exécution du programme. Elle est appelée constante parce qu'elle reste toujours la même.

La syntaxe de base d'une constante est name : type = value. name correspond au nom que vous attribuez à la constante (appelé identificateur). Le signe : indique qu'un type va être spécifié. Le signe = indique qu'une valeur va être spécifiée, suivie de la valeur proprement dite. Par exemple :

PlayerSpeed : float = 2.0

Cela indique que PlayerSpeed a une valeur de 2,0, représentée par une valeur décimale qui ne change pas pendant l'exécution du programme.

Les constantes disposent toujours de valeurs assignées. Le nom et le type correspondent à la déclaration, et l'initialisation au moment où cette valeur est exprimée.

Comparez cette définition à celle du terme variable.

Pour plus d'informations, voir Constantes et variables.

Lorsqu'une expression est limitée, elle a des limites définies.

Vous pouvez stocker plusieurs valeurs ensemble en utilisant un type de conteneur tel qu'une matrice, un mappage, un tuple et une option.

Dans l'UEFN, un conteneur est une classe qui contient des propriétés pouvant être appliquées à plusieurs objets.

Dans Verse, un conteneur est un moyen d'organiser les données dans le code. Pour en savoir plus, consultez la rubrique Type de conteneur.  

L'étendue de code qui définit la durée de vie de divers éléments et contraintes du langage. Il s'agit généralement de la plage entre le début et la fin d'un bloc de code.

Un changement de contexte est le processus qui consiste à stocker l'état d'un processus ou d'un thread afin de pouvoir le restaurer et en reprendre l'exécution ultérieurement, puis à restaurer un état différent, précédemment enregistré.

L'écriture de code est parfois comparée à la conclusion d'un contrat avec le génie dans le sens où un programme suivra exactement vos instructions, même lorsque le résultat n'est pas exactement celui que vous attendez. Consultez également la définition de programme.

L'ensemble d'effets "le plus petit". Il s'agit d'un code qui est garanti de produire une valeur en un temps fini sans diverger.

Une routine à durée de vie qui effectue un travail dans le temps ou attend que divers événements et états se produisent, ou une combinaison des deux. Coroutine est synonyme de fonction asynchrone.

En général, les données désignent les valeurs utilisées dans une expression.

Voir membre.

Voir type.

Outil utilisé pour le débogage, qui vous permet d'afficher l'état du programme à chaque étape d'exécution.

Processus d'identification et de résolution des erreurs dans votre code.

Effet qui indique que la fonction peut échouer, et que l'appel de cette fonction est une expression faillible. Les définitions de fonction avec l'effet decides doivent également disposer de l'effet transacts. En d'autres termes, les actions exécutées par cette fonction peuvent être annulées comme si les actions n'avaient jamais été effectuées en cas d'échec de la fonction.

Les expressions de décision utilisent les opérateurs not, and et or pour vous permettre de contrôler le flux de décision de réussite et d'échec.

Une déclaration est une expression dans laquelle un identificateur est introduit, ainsi que son type. Elle peut être implémentée (utilisée) ou non, et une valeur peut lui être attribuée ou non (initialisée).

var name : type = expression est la syntaxe pour la déclaration d'une variable. Par exemple :

var PlayerSpeed : float = 2.0

Cette ligne de code déclare qu'une variable nommée PlayerSpeed a une valeur float.

Dans cet exemple, la dernière partie, = 2.0, est l'initialisation, qui est séparée de la déclaration.

Vous déclarez une variable ou une fonction en spécifiant son identificateur et son type. Comparez cette définition à initialiser.

En programmation, décorer signifie envelopper un bout de code dans un autre.

Voir définition.

Une définition correspond à l'implémentation d'un identificateur ou à l'assignation d'une valeur, comme dans le cas d'une définition de fonction ou d'une définition de classe. Comparez cette définition à celle de déclaration.

La dépendance est la situation où un module dépend d'autres modules pour une fonctionnalité.

Un système déterministe est un système dans lequel le même état initial ou la même entrée produira toujours les mêmes résultats.

La destruction déterministe, rencontrée dans certains langages de programmation, consiste à détruire les objets lorsqu'un programme sort de leur étendue.

Liste générée automatiquement de tous les symboles publics, tels que les modules, les fonctions, les classes, que le compilateur Verse a traités. Elle inclut également les commentaires. Vous pouvez lire un fichier digest pour voir quelle API et quelle fonctionnalité se trouvent dans un module associé.

Expédier, c'est envoyer quelque chose quelque part. Dans Verse, cela peut consister à envoyer un appel à une fonction ou à envoyer un événement à un auditeur, par exemple.

L'exécution d'un programme est dite divergente si elle ne se termine pas comme prévu. Si elle donne une valeur dans un temps fini sans diverger, elle converge.

Champ de remarque générique présent dans les classes et les fonctions (mais pas les paramètres de fonctions). Il contient des informations utiles sur ce que fait l'élément qu'il décrit ou sur la façon de l'utiliser, et il est utilisé pour renseigner la page de cet élément dans la référence API de Verse.

Le domaine est l'ensemble des entrées acceptées par un paramètre particulier. Un type est une façon de spécifier un domaine, mais le domaine est plus englobant que le type.

Dans un langage de programmation à typage dynamique, les variables et les expressions n'ont pas de types assignés. Cela signifie qu'elles ne peuvent être vérifiées qu'au moment de l'exécution. Comparer à fortement typé.

Un dépassement sur les entiers se produit lorsqu'a lieu une tentative de stockage d'une valeur supérieure à la limite définie.

Toute personne qui fait appel aux outils de Fortnite pour créer (développer) une île dans Fortnite, en particulier lorsqu'elle utilise l'UEFN. Ce terme englobe les développeurs d'îles, les artistes et les architectes Fortnite. 

Attribut que vous pouvez ajouter au code pour exposer les propriétés dans l'UEFN. Le code de balisage avec cet attribut consiste à ajouter un @attribute_name (en l'occurrence @editable) devant un identificateur de champ :

@editable
PropertyName : type = DefaultValue

Par exemple, le champ de chaîne GreetingMessage est une propriété modifiable avec la valeur par défaut "Hello, stranger" :

expose_properties := class(creative_device):
  @editable
  GreetingMessage : string = "Hello, stranger"

Pour en savoir plus sur la façon de l'utiliser, consultez Personnaliser les propriétés de votre appareil dans l'éditeur.

Un effet est une catégorie de comportement qu'une fonction peut montrer.

Dans l'exemple ci-dessous, le code indique qu'une fonction est nommée IsCriticalHealth et prend une valeur entière en entrée via le paramètre Health. Ensuite, il est indiqué que les effets que la fonction montre sont decides et transacts, ce qui signifie que la fonction est un contexte d'échec et que ses actions peuvent être annulées si la fonction échoue. Si la valeur Health transmise en tant qu'entrée de la fonction est supérieure à 0.0 et inférieure ou égale à 30.0, alors la fonction réussit. Sinon, la fonction échoue, et le contexte qui a appelé la fonction doit gérer l'échec.

IsCriticalHealth(Health : float)<decides><transacts> : void =
    ((Health > 0.0) && (Health <= 30.0))

Pour en savoir plus, consultez Spécificateurs et attributs.

Un effet est une catégorie de comportement qu'une fonction peut montrer. L'application d'effets exclusifs à une fonction est hiérarchisée, les effets les plus élevés de la hiérarchie autorisant au moins tous les comportements des effets inférieurs. La hiérarchie est :

1. transacts

2. varies

3. computes

4. converges

L'effet transacts inclura les propriétés des effets ci-dessous, l'effet varies inclut les effets computes et converges, mais pas transacts, et ainsi de suite.

Une seule partie dans un groupe plus grand. Par exemple, une matrice peut contenir différents éléments qui peuvent être stockés et utilisés individuellement. 

Un bloc de code qui ne contient aucune expression est un bloc vide. Les blocs vides ne sont généralement utilisés qu'en tant qu'espaces réservés et recevront ultérieurement du code.

Une chaîne ne contenant aucun caractère "" est appelée chaîne vide.

Dans Verse, les expressions d'égalité sont utilisées lorsque vous comparez si deux éléments sont égaux en utilisant l'opérateur =.

Le caractère d'échappement de Verse est la barre oblique inverse ( \ ), qui crée une séquence d'échappement dans un littéral de chaîne. Il est utilisé pour modifier les caractères de contrôle qui seraient autrement interprétés différemment. Par exemple, si vous travaillez avec une chaîne et voulez inclure des caractères dont l'utilisation est prédéfinie, comme { }, vous devez inclure le caractère d'échappement "" avant le caractère dans la chaîne. Ainsi, "\\{\\}" est rendu par {} dans le texte.

Évaluer consiste à exécuter une expression pour produire une valeur.

Quelques effets sont considérés comme des effets exclusifs auxquels des effets additifs peuvent être ajoutés, mais qui ne peuvent pas être utilisés avec d'autres effets exclusifs. Parmi les effets exclusifs figurent computes, varies et transacts. Parmi les effets additifs figurent suspends et decides.

Faire fonctionner un programme.

Le processus par lequel un ordinateur interprète un programme et exécute les instructions de ce programme.

Une propriété est exposée dans l'UEFN en lui attribuant l’attribut editable dans le code Verse. Vous pouvez ainsi modifier la propriété exposée directement dans l'interface de l'UEFN. Voir aussi modifiable.

Une expression est la plus petite unité de code (une combinaison de valeurs et de fonctions) qui a un résultat lorsqu'elle est évaluée.

L'exemple ci-dessous est une expression if… else, ce qui signifie que si la valeur répond à un critère nommé, elle est une chose, sinon elle est autre chose.

if (a > 5):
  “Big!”
else
  “Small!”

Dans Verse, tout est une expression, des littéraux aux appels de fonction ou au flux de contrôle.

Cela se compare à une instruction, qui est une commande autonome qui n'a pas de valeur résultante. Dans Verse, tout est une expression, et il n'y a pas de distinction entre les instructions et les expressions qui peuvent être évaluées à une valeur.

Pour en savoir plus, consultez la page Expressions.

Voir float.

Dans Verse, par défaut, aucun code écrit par l'utilisateur ne peut échouer. Cela signifie qu'au lieu d'avoir une fonction qui renvoie des variables booléennes ou des options, elle utilise <decides> pour renvoyer une valeur, un vide ou un échec.

Une expression faillible est une expression qui peut réussir et produire une valeur ou échouer et ne renvoyer aucune valeur. Parmi les exemples d'expressions faillibles figurent l'indexation dans une matrice, car un index invalide échouera, et l'utilisation d'opérateurs, comme la comparaison de deux valeurs.

Un contexte d'échec est un contexte dans lequel il est permis d'exécuter des expressions susceptibles d'échouer. Le contexte définit ce qui se passe si l'expression échoue.

Voir membre.

Spécificateur ne pouvant être utilisé que sur les classes et les membres des classes.

• Lorsqu'une classe possède le spécificateur final, vous ne pouvez pas créer de sous-classe de la classe.

• Lorsqu'un champ possède le spécificateur final, vous ne pouvez pas remplacer le champ dans une sous-classe.

• Lorsqu'une méthode possède le spécificateur final, vous ne pouvez pas remplacer la méthode dans une sous-classe.

L'expression « fire-and-forget (tire et oublie) » fait référence à une expression dont l'achèvement et même le succès vous sont indifférents. Cette situation est extrêmement rare.

Un terme utilisé dans divers langages de programmation pour définir une variable avec une valeur fractionnaire ou un nombre qui contient un point décimal, comme 0.5 ou 1.0. Les nombres créés à l'aide d'une déclaration de variable float auront des chiffres des deux côtés d'une virgule décimale.

Opération mathématique qui arrondit une valeur rationnelle au nombre entier inférieur le plus proche. Comparez cette définition à celle de Ceil.

Une fonction (également appelée routine) est un code réutilisable qui fournit des instructions pour exécuter une action ou créer une sortie en fonction de l'entrée.

Pour définir une fonction, vous devez spécifier trois éléments clés : un nom unique, le type d'information que vous pouvez attendre comme résultat, et l'action déclenchée par l'appel de la fonction.

Voici la syntaxe de base d'une fonction :

name() : type =  codeblock

• Name() et type séparés par deux points : il s'agit de la signature de la fonction, qui indique comment vous devez appeler et utiliser cette fonction, mais qui indique aussi que la valeur qui doit être renvoyée par la fonction est du type que vous fournissez. Ce format est semblable à la façon dont vous créez des constantes, à l'exception des () après le nom, qui reproduisent le mode d'appel de la fonction dans votre code.

• Le bloc de code de la fonction : vous définissez l'action qu'exécute la fonction lorsqu'elle est appelée en fournissant =codeblock, codeblock étant une séquence d'une ou de plusieurs expressions. Chaque fois que vous appelez la fonction, les expressions du bloc de code sont exécutées.

Une expression for, parfois appelée boucle for, est identique à une expression loop, sauf que les expressions for sont limitées, ce qui signifie que le nombre d'itérations est connu avant l'exécution de la boucle for, et que les décisions sur le moment de quitter la boucle sont automatisées. Pour en savoir plus, consultez For.

Image rendue entièrement (par exemple, sur un écran d'ordinateur ou une télévision), qui représente une simulation à un moment donné. Ce mot est parfois synonyme de mise à jour (ou tick) de la simulation, car elles se font généralement au même rythme, bien que de nouvelles images puissent être générées à une fréquence différente (supérieure ou inférieure) de la mise à jour de la simulation. La fréquence d'images, ou ips (images par seconde) en abrégé, est le nombre d'images qui apparaissent par seconde.

  Expression qui évalue (connue sous le nom d'appel) une fonction. Les appels de fonction peuvent avoir deux formes, selon que la fonction comporte ou non l'effet decides : FunctionName() et FunctionName[]. Le type de résultat de l'expression d'appel de fonction est défini dans la signature de la fonction.  

La signature de fonction déclare le nom de la fonction (identificateur), ainsi que l'entrée (paramètres) et la sortie (résultat) de la fonction. Les fonctions Verse peuvent également avoir des spécificateurs qui précisent la manière d'utiliser ou d'implémenter une fonction.

Combinaison des paradigmes de programmation fonctionnelle et de programmation logique en un seul langage.

Type de programmation déclarative axé sur l'utilisation de fonctions. La programmation fonctionnelle a pour but de faciliter le test et le débogage en réduisant les effets secondaires. Haskell est un exemple de langage de programmation fonctionnelle.

Une tâche qui a commencé à s'exécuter, mais qui a été suspendue sans être annulée. Elle est future, car elle se terminera à un moment donné dans le futur.

Une boucle de jeu est un code qui s'exécute de manière répétée (en boucle) pour répondre aux commandes (généralement, les interactions du joueur avec sa manette ou sa souris) pour actualiser l'état du jeu et fournir une sortie montrant au joueur qu'il a affecté l'état du jeu, par exemple lorsqu'il appuie sur un bouton qui allume une lumière. En général, la boucle se termine lorsque le jeu atteint un état d'achèvement, par exemple lorsque le joueur atteint un objectif, ou un état d'échec si le temps imparti s'écoule avant que le joueur ait atteint l'objectif.

L'état d'un jeu ou d'une autre simulation. Il est composé de toutes les valeurs de données qui décrivent un système. Les valeurs constantes et variables déterminent l'état du système.

Un générateur produit une séquence de valeurs, une à la fois, et donne un nom à la valeur dans la séquence.

L'action d'entourer une expression entre (). Ceci spécifie explicitement l'ordre d'évaluation. Le regroupement peut également améliorer la lisibilité du code.

Un gestionnaire est la fonction qui est appelée pour répondre à un événement lié. Par exemple, si vous liez une fonction à l'événement InteractedWithEvent d'un bouton, chaque fois qu'un joueur interagit avec ce bouton, le gestionnaire associé à cet événement est appelé.

Les données codées en dur sont écrites directement dans le code au lieu d'être assignées à une variable. Cela rend le code moins souple et plus difficile à modifier, mais certaines circonstances justifient son utilisation.

Dans Verse, vous pouvez utiliser le système numérique hexadécimal (base 16) pour représenter des entiers, au lieu du système numérique décimal qui utilise la base 10. Cela signifie que les valeurs hexadécimales sont représentées par les chiffres 0 à 9 et les lettres A à F. Par exemple, 0x7F est identique à 127, et 0xFACE est identique à 64206.

Il s'agit d'une autre façon de représenter les nombres entiers.

Disposer de niveaux ou de hiérarchies claires de classement, d'importance ou de contrôle. Les relations hiérarchiques les plus courantes sont de type parent/enfant ou super-classe/sous-classe.

Un environnement de développement intégré (EDI) est un logiciel qui fournit une interface utilisateur pour créer et déboguer des programmes.

Un identificateur est le nom attribué aux éléments d'un programme, tels que les variables ou les fonctions, afin de ne pas les confondre.

Avec l'expression if, vous pouvez prendre des décisions qui modifient le flux du programme. Comme avec d'autres langages de programmation, l'expression if de Verse prend en charge l'exécution conditionnelle, mais dans Verse, les conditions utilisent la réussite et l'échec pour motiver la décision.

Une expression immédiate s'évalue sans délai, ce qui signifie que l'évaluation sera terminée dans la mise à jour de la simulation actuelle.

Une fois qu'un objet a été créé, son état ne peut plus être modifié. Comparer à mutable.

Un paradigme dans lequel le programme décrit explicitement la manière dont un programme s'exécute, étape par étape. C est un exemple de langage de programmation impérative.

Un index représente les positions des éléments d'une séquence par une représentation numérique. Une séquence peut être une liste, une chaîne de caractères ou toute séquence arbitraire de valeurs.

Les index utilisent la numérotation à partir de zéro. La première position de l'index est donc 0 et la cinquième position est 4.

Dans certains cas, il n'est pas nécessaire de spécifier explicitement le type, par exemple lors de la création d'une constante. Par exemple, dans MyConstant := 0, le type de MyConstant est déduit comme étant int, car une valeur entière lui est attribuée. Dans des cas comme celui-ci, le type est déduit.

Un bloc de boucle qui se répète indéfiniment. Voir aussi loop et break.

Un format pour un opérateur dans lequel il y a deux opérandes et l'opérateur se trouve entre les opérandes.

Dans Verse, vous pouvez créer une classe qui étend la définition d'une autre classe en ajoutant ou en modifiant les champs et les méthodes de l'autre classe. Cette méthode est souvent appelée sous-classement ou héritage, car une classe hérite des définitions de l'autre classe.

Pour créer une variable, spécifiez son identificateur et son type, ce qui s'appelle déclarer une variable, et attribuez une valeur à la variable, ce qui s'appelle initialiser.

Une instance est une copie unique d'une ressource. La ressource originale détermine les propriétés par défaut de toute nouvelle instance que vous créez. Les modifications que vous apportez aux propriétés d'une instance n'ont aucune incidence sur la ressource originale. Par exemple, vous pouvez modifier l'apparence d'un matériau sans modifier le matériau maître. Il s'agirait alors d'une instance de matériau.

Dans Verse, pour créer une variable, indiquez son identificateur et son type, ce qui s'appelle déclarer une variable, et assignez une valeur à la variable, ce qui s'appelle initialiser.

Pour créer une instance de quelque chose.

Dans Verse, instancier signifie créer une instance ou une valeur d'une structure de données ou d'un type telle qu'une classe ou une structure. Voir également instanciation d'archétype.

Un nombre entier est un nombre non décimal qui peut être positif, négatif ou nul.

Une classe marquée epic_internal signifie que vous ne pouvez pas créer votre propre instance de la classe. Vous ne pouvez utiliser les API que pour accéder à un objet interne.

Le mélange de nouvelles valeurs qui se situent entre des valeurs connues.

Un programme qui analyse et exécute un programme ligne par ligne.

Temps nécessaire pour évaluer une expression. Une invocation immédiate ne prend en réalité pas de temps. Une expression asynchrone peut se terminer immédiatement ou être latente.

Voir appel.

La relation entre une classe parente et une classe enfant s'appelle une relation "is-a". La classe enfant dans une relation is-a hérite de la classe parente.

Exécuter du code pour chaque élément d'une séquence.

Lorsqu'une clé est associée à une valeur, elles forment ensemble une paire clé-valeur. Vous pouvez rechercher la valeur à l'aide de la clé.

Les mots-clés sont des mots réservés qui ont une signification particulière pour le compilateur. Des exemples de mots-clés sont for et class. Les mots-clés ne peuvent pas être utilisés comme identificateurs.

Voir durée de vie.

Le temps entre la création d'un objet et sa destruction. Synonyme de temps de vie.

Structure de données linéaire dans laquelle chaque élément stocke une référence à l'élément suivant de la liste.

Chaque élément d'une liste chaînée est appelé un nœud. Un nœud est un conteneur qui contient des données et une référence au nœud suivant.

Une valeur fixe dans le langage de programmation Verse, comme un nombre ou un caractère. Par exemple, 1 est un littéral de nombre entier.

Fait référence à une constante ou à une variable à l'intérieur d'un bloc de code. Elles ne peuvent pas être utilisées en dehors du bloc de code dans lequel elles ont été créées. Voir aussi étendue.

En programmation, un paramètre régional est un ensemble de paramètres qui définit la langue et la région d'un utilisateur ainsi que d'autres aspects de l'interface utilisateur. Dans Verse, le paramètre régional locale désigne un type qui définit un contexte qui indique quand traduire un message et qui modifie la langue du texte et des chiffres en fonction de ce paramètre régional.

Paradigme de programmation utilisant la logique booléenne pour contrôler la représentation ou l'expression des faits et des règles concernant les problèmes dans le système.

Dans Verse, on parle d'expression mathématique lorsqu'une expression utilise l'un des opérateurs suivants : +, -, * ou /.

Variable ou fonction nommée qui est une sous-partie d'une structure de données composite (comme une classe, une structure, une interface ou un module Verse). Les variables membres sont souvent appelées champs, et les fonctions membres, méthodes.

Dans Verse, un message est un type pouvant contenir du texte indépendant des paramètres régionaux. Lorsque vous initialisez une variable de message avec une valeur string, cette chaîne correspond au texte et à la langue par défaut du message.

Un monde en 3D en temps réel, persistant et globalement cohérent, avec un environnement d'exécution qui exécute du code écrit par les utilisateurs, complexe et interdépendant, avec des millions d'utilisateurs connectés simultanément.

Une méthode est une fonction liée à une classe et qui ne peut être appelée que sur une instance de cette classe.

Processus de lecture ou d'écriture de données vers ou depuis le fichier d'enregistrement. Une propriété libre est créée avec le même fichier en cours de lecture qui possède une propriété que la classe/structure n'a pas.

Inverser la direction d'une animation, puis l'inverser à nouveau une fois la dernière image atteinte.

Un module Verse est une unité atomique de code qui peut être redistribuée et dont on peut dépendre, et qui 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.

Pour plus d'informations, consultez Modules et chemins.

Il s'agit de l'état d'un objet qui peut encore être modifié après sa création. Dans Verse, la mutabilité n'est possible qu'avec des pointeurs.

Comparer à immuable.

Un mutex est une primitive de synchronisation qui accorde un accès exclusif à une ressource partagée en utilisant un seul thread. Voir aussi exclusion mutuelle.

Lorsque plusieurs processus accèdent au même segment de code, ce segment est appelé la section critique. L'exclusion mutuelle est un moyen de s'assurer que deux processus ne peuvent pas accéder simultanément à une section critique.

Une valeur qui ne représente pas un nombre. NaN est le sigle de "Not a Number", littéralement : pas un nombre.

native indique que les détails de définition d'un élément sont implémentés en C++. Ce spécificateur peut générer automatiquement des définitions C++ qu'un développeur peut ensuite utiliser. Le spécificateur native est utilisé sur la classe, l'interface, l'énumération, la méthode et les données.

Indique qu'une méthode d'instance est à la fois native (implémentée en C++) et peut être appelée par un autre code C++. Vous pouvez voir ce spécificateur utilisé sur une méthode d'instance. Ce spécificateur ne se propage pas aux sous-classes. Vous n'avez donc pas besoin de l'ajouter à une définition lorsque vous remplacez une méthode disposant de ce spécificateur.

Lorsque le code est imbriqué, un bloc de code est contenu dans un autre bloc de code qui remplit une fonction élargie.

Cet effet indique que les lectures et écritures de données mutables d'une fonction ne peuvent pas être annulées, ce qui signifie que la fonction ne peut pas être appelée dans un contexte d'échec (qui a un comportement d'annulation en cas d'échec).

Dans l'UEFN, un nœud est une unité fondamentale au sein d'un système basé sur un graphique qui représente une fonction, une opération ou un point de données spécifique. Dans le contexte des graphes de nœud, un nœud est un composant individuel qui traite ou achemine les signaux audio, tels qu'une source sonore, un effet (comme une réverbération ou un délai), un mixeur ou une sortie.  

Pour Verse, voir nœud de liste chaînée.

Dans l'UEFN, le terme "objet" est synonyme de ressource.

Dans Verse, une instance d'une classe est un objet. Une instance a les mêmes comportements définis par son type de classe, mais avec des valeurs réelles.

Les termes instance et objet sont synonymes.

La programmation orientée objets (POO) est un paradigme de programmation qui repose sur le concept de classes et d'objets.

Un langage dans lequel des modules interdépendants écrits par de nombreux utilisateurs et organisations différents peuvent évoluer dans le temps sans rompre la compatibilité des interfaces et des données persistantes en suivant des règles de sous-typage clairement définies.

La quantité sur laquelle une opération est effectuée. Par exemple, dans l'expression 1 + 2, le + est un opérateur, et 1 et 2 sont deux opérandes.

Action exécutée par un programme pour accomplir une tâche spécifique. Il existe quatre groupes fondamentaux d'opérations informatiques : entrée, traitement, sortie et stockage. Une opération est un type d'expression.

Un symbole qui représente une action ou un processus. Par exemple, dans 1 + 2, le + est l'opérateur.

Il s'agit de l'ordre d'évaluation intégré lors de la combinaison d'opérateurs dans Verse. Par exemple, si plusieurs opérateurs sont utilisés dans la même expression, l'ordre dans lequel ils sont évalués est important.

Par exemple, 1 + 2 * 3 ne produit pas le même résultat que 3 * 3, car la multiplication prévaut sur l'addition.

La précédence des opérateurs peut être remplacée par le regroupement d'expressions.

Fait référence à la précédence des opérateurs : l'ordre dans lequel certaines opérations doivent être effectuées dans une expression.

La surcharge d'une fonction ou d'un opérateur signifie que le même nom de fonction ou symbole d'opérateur peut avoir différents paramètres. Par exemple, si vous dites qu'un vecteur 3D est égal à un autre vecteur 3D, comme (1,2,3), cela est assez clair. Toutefois, vous pouvez utiliser l'opérateur `equals` pour dire que votre vecteur 3D est égal à un seul nombre, par exemple 1. Dans ce cas, le vecteur 3D est peut-être défini comme (1,1,1), mais la partie surchargée est constituée de plusieurs opérateurs "3D Vector =" avec différents paramètres. Le langage devrait examiner le contexte pour savoir lequel utiliser.

Dans Verse, vous pouvez remplacer les champs d'une super-classe et leur assigner des valeurs initiales. Par exemple :

tank := class(player_character):
  StartingShields<override> : int = 100
  MaxShields<override> : int = 200
  AllowOvershield<override> : logic = true
  DamageReduction : int = 50
 
CreateTankPlayerCharacter() : tank =
  return tank{}

Dans la classe tank, les valeurs pour StartingShields, MaxShields et AllowOvershield sont différentes des valeurs de classe par défaut.

Vous pouvez également remplacer les valeurs de méthode de la même façon.

Pour en savoir plus, consultez la rubrique sous-classe.

Modèle ou schéma habituel de quelque chose. En programmation, un paradigme est la façon dont un langage de programmation est organisé. Il existe quatre paradigmes principaux pour les langages de programmation :

1. Impératif

2. Logique

3. Fonctionnel

4. Orienté objet

Il existe également des langages multiparadigmes, comme Verse.

Les calculs multiples qui s'exécutent dans le même laps de temps physique, par exemple sur des processeurs distincts, sont parallèles.

Variable d'entrée qui comprend un domaine tel qu'un type et une valeur par défaut facultative définie dans une signature de fonction, qui est ensuite utilisée dans le corps de la fonction. Comparez cette définition à argument.

Type qui peut prendre un paramètre.

L'analyse syntaxique, en informatique, consiste à séparer une chaîne de commandes, généralement un programme, en composants plus faciles à traiter, qui sont analysés pour vérifier que la syntaxe est correcte, puis liés à des balises qui définissent chaque composant.

Programme permettant d'analyser le code.

Les chemins Verse fournissent un espace de noms global pour identifier les objets, à l'instar des domaines Internet. Ces chemins sont persistants, uniques, et peuvent être découverts par n'importe quel programmeur Verse.

Perforce (P4) est un outil logiciel permettant le contrôle de révision (également appelé contrôle du code source ou contrôle de version), qui permet de suivre et de gérer les modifications apportées au code logiciel. Cette fonction est utile lorsque des équipes de programmeurs travaillent sur un même projet. Si quelqu'un fait une erreur, le contrôle de version permet de comparer les versions précédentes du code afin de détecter et de corriger le problème sans interrompre le travail des autres.

Lorsque les données des joueurs sont enregistrées à partir d'une session et rechargées dans la session suivante de ce jeu, on parle de persistance.

La surface sur laquelle un jeu est joué. Traditionnellement, le terme plateau de jeu s'applique aux jeux sur table. Cependant, il est de plus en plus couramment utilisé pour décrire les niveaux des jeux vidéo. Dans le domaine du développement de jeux vidéo, les niveaux d'un plateau de jeu peuvent être divisés en différentes régions ou zones, avec des formes, des dispositions ou des terrains différents. À l'instar des plateaux des jeux de société, les joueurs peuvent déplacer des personnages ou des objets sur le plateau (niveau) pour progresser dans le jeu.

Module d'API Verse que vous pouvez utiliser pour obtenir une matrice de joueurs ou d'équipes, ou l'équipe d'un joueur particulier. Il vous permet également de vous abonner aux événements avec joueurs et sans joueurs.

Un pointeur est un moyen de référencer une "boîte" mutable qui peut contenir un type de valeur spécifié. Avec un pointeur, vous pouvez modifier la valeur spécifique de cette boîte. Comparez cette définition à valeur.

Une variable de pointeur indique un emplacement de la mémoire où une valeur est stockée. Après avoir créé une variable de pointeur, vous ne pouvez pas modifier l'emplacement de la mémoire de la variable de pointeur, mais vous pouvez modifier la valeur stockée à cet emplacement de la mémoire.

L'interrogation fait référence à l'échantillonnage actif de l'état d'un appareil externe par un programme client en tant qu'activité synchrone. L'interrogation est le plus souvent utilisée en termes d'entrée/sortie (E/S), et est également appelée E/S interrogée ou E/S pilotée par logiciel.

Polymorphe vient de poly-, qui signifie plusieurs, et -morph, qui signifie forme. Un comportement polymorphe se produit lorsqu'une variable peut avoir des valeurs différentes dans des conditions différentes.

Format d'opérateur situé après l'unique opérande.

Ordre dans lequel certaines opérations doivent être effectuées dans une expression.

Dans Verse, un prédicat est quelque chose qui réussit ou échoue.

L'interruption temporaire d'une tâche en cours d'exécution avec l'intention de la reprendre plus tard s'appelle préemption. Cette opération est généralement effectuée par un planificateur externe, sans aide ni coopération de la part de la tâche.

Format d'opérateur situé avant l'unique opérande.

Un type primitif est tout type qui n'est pas créé à partir d'autres types. Cela signifie qu'un primitif n'est pas un composite et qu'il ne peut pas être décomposé davantage. Les exemples de types primitifs intégrés incluent void, logic, int, float, rational et char. Les primitifs sont intégrés au langage Verse.

Comparer à type de conteneur.

Un programme est un ensemble d'instructions qui indique à l'ordinateur la manière de faire quelque chose. La base de tout programme est de montrer comment l'ordinateur va recevoir des entrées et renvoyer des sorties.

Un programme résout les problèmes. Mais les programmes sont très littéraux. C'est comme passer un contrat avec un génie. Le génie (le programme) vous donnera exactement ce que vous demandez. Exactement. Des erreurs se produisent lorsque le programmeur fait des hypothèses sur ce qui devrait se passer au lieu de décrire précisément les entrées recevables et les sorties qui en résultent.

L'acte d'écrire des instructions (un programme) qui peuvent être compilées et exécutées par l'ordinateur.

Un langage formel utilisé pour écrire des programmes informatiques. Il existe de nombreux langages de programmation, et chacun a ses propres règles. Par exemple, Scratch, un langage de programmation visuel utilisé pour développer des histoires interactives, des jeux et des animations, ou C++, un langage textuel fréquemment utilisé pour le développement de jeux. Verse est un langage de programmation développé par Epic Games pour les créateurs qui souhaitent en savoir plus sur l'utilisation des outils de développement.

La propagation dans une fonction est ce qui se produit si l'appelant n'a pas à gérer ce qui se passe en cas d'échec. Par exemple, une fonction avec un effet decidespeut être appelée par une autre fonction avec un effet decides. L'appelant devra alors gérer l'échec, quoi qu'il ait appelé.

Une propriété est un membre (champ) qui permet de renvoyer des valeurs et de les exposer.

Le pseudo-code est une description détaillée en langage clair (et non en langage de programmation) de ce qu'un algorithme doit faire. Dans la mesure où pseudo signifie faux ou factice, le pseudo-code est un code factice, mais qui sert à déterminer les tâches d'un algorithme.

Vous pouvez aussi considérer le pseudo-code comme un plan de haut niveau. On écrit généralement le pseudo-code pour planifier une partie complexe ou volumineuse d'un programme avant d'écrire le code réel.

Membre visible par les autres modules.

Déclare qu'une fonction fournira toujours exactement la même sortie pour la même entrée, et qu'elle n'a pas d'effets secondaires (écritures dans des variables mutables, effets ES, etc.).

Permet de définir un identificateur dans une étendue qui permet à l'identificateur d'être "réutilisé". Par exemple, vous pouvez avoir une constante qui s'appelle "cat." Vous pouvez utiliser le même nom pour un champ de classe nommé "sarah.cat". "cat" figure dans les deux noms, mais "sarah.cat" a été qualifié.

Les expressions de requête utilisent l'opérateur ? pour vérifier si une valeur logique ou facultative est vraie.

Une condition `race` se produit lorsqu'un programme tente d'effectuer deux opérations ou plus en même temps, alors que ces opérations devraient être effectuées en séquence pour s'exécuter correctement.

Acronyme signifiant resource acquision is initialization, RAII décrit le moment où un objet acquiert des ressources entre l'initialization et la finalisation uniquement, afin de gérer les ressources plus efficacement.

Lorsqu'une fonction émet un signal, elle déclenche un événement. Les parties intéressées sont informées qu'un événement s'est produit, notamment l'interaction avec un bouton, et tous les gestionnaires d'événements sont appelés.

Les expressions de plage contiennent tous les nombres compris entre deux valeurs spécifiées, ces deux valeurs comprises, et les séparent par .., par exemple : 1..5. Les expressions de plage ne peuvent être utilisées qu'à certains endroits, comme dans les expressions for.

Un nombre qui peut être exprimé sous forme de fraction simple avec deux nombres entiers. Par exemple, 1,75 peut aussi être exprimé sous la forme 7/4, mais la racine carrée de 2 (√2) ne peut pas être exprimée sous forme de fraction. Elle est donc considérée comme un nombre irrationnel. Un autre exemple de nombre irrationnel est Pi, qui commence par 3,14159… et continue à l'infini.

Le ray-casting trace une ligne invisible dans l'espace à partir d'un objet pour déterminer s'il entre en collision avec un autre objet.

On parle de récursivité lorsqu'une fonction s'appelle elle-même.

Modifier la structure d'un code sans en changer la fonctionnalité. Par exemple, un bloc de code qui est répété plusieurs fois dans un programme peut être refactorisé en appel de fonction. La refactorisation peut améliorer la lisibilité et réduire la complexité du code sans en modifier le comportement.

Read-Evaluate-Print Loop, ou REPL, est un environnement informatique dans lequel vous pouvez saisir du code en vue de l'examiner et de l'évaluer, puis d'en afficher les résultats. Un environnement REPL vous donne la possibilité d'explorer un langage sans le dégrader, et de déterminer ce qui fonctionne ou ne fonctionne pas.

Lorsqu'une expression s'exécute, puis produit une valeur, cette valeur est un résultat.

Expression qui demande à un programme de quitter une sous-routine et de revenir à l'adresse de retour. L'adresse de retour est l'endroit d'où la sous-routine a été appelée.

Au lieu de compter sur la dernière expression du bloc de code de la fonction pour produire la bonne valeur, vous pouvez spécifier explicitement le résultat en utilisant une expression return. Lorsque l'expression de retour est exécutée, elle quitte immédiatement le bloc de code de la fonction. En d'autres termes, si vous placez l'expression de retour avant un autre code, le code qui suit ne s'exécute pas.

Restaurer un programme à un état défini précédemment, généralement pour récupérer d'une expression ayant échoué.

Voir Fonction.

Ce terme désigne le temps passé à exécuter le jeu, la simulation ou l'application. Comparez cette définition à celle du temps de compilation, qui désigne le temps passé à compiler, ou au temps de développement, qui désigne le temps passé à développer, compiler et déboguer.

Il est courant de différencier ce qui se produit pendant l'exécution de ce qui se produit pendant la compilation.

Boucle infinie survenant quand une fonction s'appelle elle-même indéfiniment. Elle entraîne une suspension du programme.

L'étendue désigne la partie du programme où l'association d'un nom à une valeur est valide et où ce nom peut être utilisé pour faire référence à la valeur. Par exemple, les constantes ou les variables que vous créez dans une fonction n'existent que dans le contexte de la fonction. Cela signifie que la durée de vie des objets est limitée à l'étendue dans laquelle ils sont créés, et qu'ils ne peuvent pas être utilisés en dehors de ce bloc de code.

Quantité autonome de code Verse exécutable associée à un objet.

Self est un identificateur spécial dans Verse qui peut être utilisé dans une méthode de classe pour faire référence à l'instance de la classe sur laquelle la méthode a été appelée. Vous pouvez faire référence à d'autres champs de l'instance sur laquelle la méthode a été appelée sans utiliser Self, mais si vous devez faire référence à l'instance dans son ensemble, vous devez utiliser Self.

Voir Erreur de compilation.

La signification d'une expression. Comparez à syntaxe.

Un sémaphore est semblable à un mutex, mais, contrairement à un mutex, qui verrouille les autres threads sans ressource disponible, un sémaphore indique uniquement que la ressource est utilisée.

Le code est généralement exécuté ligne par ligne, dans l'ordre d'apparition des expressions. Ce processus est appelé exécution séquentielle.

Mot-clé qui peut être utilisé pour modifier la valeur d'une variable pendant l'exécution du programme.

La syntaxe est la suivante : set name = value. set est le mot-clé, name correspond au nom de la variable à modifier, et value est le résultat de cette modification.

Cette opération est appelée assignation.

On parle d'occultation lorsqu'un identificateur masque un autre identificateur. L'occultation est une erreur dans Verse, et elle empêche la compilation du code.

Un effet secondaire se produit lorsqu'un code, par exemple une fonction ou une expression, modifie un état en dehors de son étendue.

Un entier signé est une valeur qui peut contenir un nombre négatif, positif ou nul. Il est appelé entier signé, car la présence d'un + ou d'un - à l'extrême gauche indique si le nombre est positif ou négatif. Un entier non signé ne peut être qu'un nombre positif ou zéro.

Répétition d'une manche, étape ou augmentation de la logique, du comportement et d'autres calculs d'une simulation. Ce terme est souvent abrégé en mise à jour ou utilisé comme synonyme de tick ou image. La mise à jour de la simulation a généralement une durée, qui peut être constante ou variée. C'est ce que l'on appelle souvent le temps delta, qui peut coïncider ou non avec le passage réel du temps. Par exemple, une mise à jour de la simulation peut être plus rapide, plus lente ou à la même vitesse que le temps réel.

La mise à jour de la simulation se fait souvent en étapes de 1:1 avec le rendu d'image ; Verse utilise ce réglage par défaut. Cependant, une mise à jour de la simulation peut être plus ou moins fréquente qu'une image, par exemple lorsqu'un client de jeu en ligne se désynchronise du serveur ou des systèmes de physique lors de la réalisation de plusieurs itérations des modifications d'un objet simulé. Il est également possible qu'une simulation n'ait aucun rendu visuel.

Voir extrait de code.

Une expression spawn lance une fonction asynchrone. Toute expression qui suit spawn s'exécute immédiatement sans attendre la fin de l'expression spawn. L'expression spawn continue indépendamment jusqu'à ce qu'elle se termine.

Un spécificateur applique des informations supplémentaires à une définition. Par exemple, le spécificateur d'effet decides sur une définition de fonction marque la fonction comme faillible.

Les spécificateurs appartiennent à l'une des deux sous-catégories suivantes : les spécificateurs d'accès et les spécificateurs d'effet.

Verse utilise le contexte d'échec pour vous permettre de tester des actions sans les valider. Cette procédure est appelée exécution spéculative. Lorsqu'une expression réussit, l'effet de cette expression est validé, par exemple le changement de valeur d'une variable. Si l'expression échoue, les effets de l'expression sont annulés, comme si l'expression n'avait jamais eu lieu.

Lorsqu'un tuple est utilisé comme élément unique d'une fonction, c'est comme si cette fonction était appelée avec chacun des éléments du tuple séparément. C'est ce qu'on appelle expansion de tuple ou projection.

Une série de fonctions, de constantes et d'autres définitions du langage disponibles dans Verse. Cette bibliothèque fournit des implémentations pour les besoins de programmation courants. Elle constitue une ressource pour les choses que les programmeurs utilisent fréquemment, comme les fonctions mathématiques.

Un état est la combinaison des valeurs d'origine d'un objet et de toutes les modifications apportées.

Une commande autonome qui n'a pas de valeur résultante. Verse n'utilise pas d'instructions. Il utilise plutôt des expressions.

Vérification automatique pendant la compilation qui peut détecter un bogue selon la sémantique du code.

La mémoire transactionnelle logicielle (_software transactional memory_ en anglais, ou STM) est un mécanisme de contrôle de la concurrence analogue aux transactions de bases de données pour contrôler l'accès à la mémoire partagée dans la programmation concurrente. À terme, Verse utilisera la STM parce qu'elle débloque des gains de performance pour les grandes simulations distribuées, entre autres motivations.

Un langage de programmation est fortement typé lorsqu'un type est assigné à chaque identificateur. Lorsque le type n'est pas explicitement fourni, il est déduit. Cela signifie que le langage ne produira pas de résultats imprévisibles pendant l'exécution, car le type de ces identificateurs et la façon dont les opérations affectent ces types sont connus. Voir aussi vérification statique.

La concurrence structurée décrit les opérations concurrentes dans une durée de vie limitée à une commande concurrente spécifique et à une étendue de contexte asynchrone. Il s'agit d'un contrôle de flux structuré comme if, for ou return qui contraint à une étendue associée.

Dans Verse, les expressions de concurrence structurées incluent sync, race, rush et branch.

Expression imbriquée dans un bloc de code.

Module Verse dans un autre module Verse. Vous pouvez considérer cela comme des dossiers et des sous-dossiers : chaque sous-module ajoute un autre /NameOfModule au chemin au fur et à mesure qu'il descend.

Un ensemble d'instructions dans un programme informatique conçu pour effectuer une opération fréquemment utilisée. Les sous-routines sont semblables aux fonctions, sauf qu'une fonction effectue certains calculs et renvoie le résultat à l'appelant. Les sous-routines effectuent leur travail sans renvoyer le résultat au programme appelant.

L'abonnement est un moyen de spécifier la fonction que vous souhaitez appeler lorsqu'un événement est déclenché. Ce processus est appelé liaison à un événement. La fonction liée est appelée gestionnaire.

Type qui prend en charge toutes les opérations de son super-type. Le mot-clé subtype peut être utilisé avec des parenthèses pour spécifier qu'un type est limité à un certain type. Par exemple, plusieurs méthodes de matrice Verse utilisent subtype pour spécifier que tous les éléments de la matrice doivent disposer du super-type comparable pour que la méthode fonctionne.

(Input:[]t where t:subtype(comparable)).RemoveFirstElement<public>
(ElementToRemove:t)<computes><decides>:[]t
RemoveFirstElement

Pour cela, les éléments de la matrice doivent disposer d'un super-type comparable afin de pouvoir déterminer si l'un des éléments de la matrice est égal à l'argument ElementToRemove.

Lorsqu'une expression se termine sans échec, elle réussit. Comparez cette définition à celle du terme contexte d'échec.

Les classes peuvent hériter d'une super-classe, qui inclut tous les champs de la super-classe dans la classe qui hérite. Ces classes sont considérées comme des sous-classes de la super-classe.

Un super-type est un type qui possède au moins un sous-type. Toutes les opérations prises en charge par un supertype doivent également être prises en charge par les sous-types. Dans Verse, any est le super-type de tous les autres types, et tous les autres types sont des sous-types d'any. Le type comparable est le super-type de tous les types comparables dans Verse, tels qu'int et float.

Effet qui arrête temporairement (suspend) une fonction sans l'annuler. Une expression suspends permet aux fonctions asynchrones de suspendre et de transférer de manière coopérative le contrôle à d'autres expressions concurrentes avant qu'elle se termine.

Pour en savoir plus, consultez la page Concurrence.

Règles, ou grammaire, du langage de programmation.

Comparez cette définition à celle de sémantique.

Voir Erreur de compilation.

Le premier nœud d'une liste chaînée est appelé nœud de tête, et le dernier nœud est appelé nœud de queue.

La plus petite unité de traitement qui peut être exécutée dans un système d'exploitation.

Consultez la définition de mise à jour de la simulation, utilisée comme synonyme de tick et, parfois, d'image.

Section de grille sur une surface telle qu'un sol ou un mur.

Le contrôle de flux temporel est au cœur du langage de programmation Verse et est réalisé avec des expressions concurrentes.

Le flux temporel est un type de contrôle de flux, mais là où le flux de contrôle concerne l'ordre dans lequel un ordinateur exécute les instructions en fonction de l'ordre des expressions dans le programme, le flux temporel contrôle l'exécution dans le temps, et non la séquence, en fonction de la façon dont les expressions concurrentes sont utilisées.

Le flux temporel est synonyme de concurrence.

Une expression de niveau supérieur est une expression qui n'est pas imbriquée dans un bloc de code. Les expressions de niveau supérieur peuvent également être des expressions composées, telles que des blocs de code imbriqués.

Lorsqu'une fonction possède l'effet transacts, cela signifie que la fonction peut lire et écrire des données, mais ces actions peuvent être annulées si la fonction possède également l'effet decides. Cet effet est un effet exclusif.

Une fonction sans effet exclusif spécifié peut lire et écrire des données, mais ne peut pas être annulée.

Le type définit les opérations qui peuvent être effectuées sur les données et la manière dont ces données, ou valeurs, sont stockées pour ce type. Il existe des types communs, tels que les nombres entiers et les chaînes, des types composites et des types personnalisés. Voir aussi type primitif et type de conteneur. Il est possible d'utiliser le keyword type entre accolades pour définir un type attendu. Les déclarations de fonctions et les plages numériques sont actuellement prises en charge en tant que déclarations. Par exemple, la fonction Subscribe() de l'interface subscribable utilise le mot-clé type pour déterminer que son paramètre Callback doit être une fonction avec un type de retour void.

Subscribe<public>(Callback:type {__(:t):void})<transacts>:cancelable

Un alias de type est un moyen de créer un nouveau nom pour un type existant. Lorsque vous déclarez un alias de type, vous pouvez alors utiliser l'alias au lieu du type existant. Un alias de type ne crée pas de nouveau type, mais fournit seulement un nouveau nom pour un type existant.

Vous pouvez convertir une classe en l'une de ses sous-classes (processus appelé conversion de type) en utilisant la syntaxe NewReference := type_to_cast_to[Reference], où type_to_cast_to correspond au type que vous voulez utiliser. Il s'agit d'une expression faillible, car la conversion de type échoue si l'objet ne peut pas être converti en ce type, par exemple, si la classe est d'un type différent de la sous-classe.

L'exemple suivant montre comment convertir TaggedDevice, qui a le type creative_device_base, en type customizable_light_device, afin d'utiliser ses fonctions spécifiques. Si le TaggedDevice n'est pas un appareil de lumière personnalisable, il n'appellera pas TurnOn().

if (LightDevice := customizable_light_device[TaggedDevice]):
  LightDevice.TurnOn()

La vérification de type est utilisée pour vérifier un programme avant son exécution. Elle vérifie les valeurs et la syntaxe des types de données. L'objectif principal d'un système de types dans un langage de programmation est de réduire la probabilité de bogues dus à des erreurs de types dans les programmes.

Norme de codage des caractères développée par le consortium Unicode afin de fournir une prise en charge comparable pour les caractères dans toutes les langues, sur toutes les plateformes et sur tous les appareils.

Le spécificateur unique peut s'appliquer à une classe pour en faire une classe unique. Pour construire une instance d'une classe unique, Verse alloue une identité unique à l'instance qui en résulte. Cela permet aux instances de classes uniques d'être comparées en matière d'égalité selon leurs identités. Les classes sans spécificateur unique n'ont pas d'identité de ce type ; il est donc uniquement possible de comparer leur égalité sur la base des valeurs de leurs champs. Cela signifie que les classes `unique` peuvent être comparées avec les opérateurs = et <>, et sont des sous-types du type `comparable`.

Aucune valeur n'est assignée. Comparer à ensemble.

Expressions concurrentes dont la durée de vie n'est pas logiquement limitée à une commande concurrente spécifique ou à une étendue de contexte asynchrone. Cette durée de vie s'étend potentiellement au-delà de l'étendue où elle a été exécutée. Elle est semblable au contrôle de flux non structuré, comme la commande goto ou assembly jump.

Le schéma de codage des caractères Unicode : une norme développée par le consortium Unicode pour fournir une prise en charge comparable des caractères dans toutes les langues, sur toutes les plateformes et sur tous les appareils.

Les emojis ressemblent à des images ou à des icônes, mais ils n'en sont pas. Ce sont des lettres (caractères) du jeu de caractères UTF-8 (Unicode).

L'UTF-8 couvre presque tous les caractères et symboles du monde.

Une validation est le moment où vous enregistrez un ensemble de changements du code dans un système de contrôle de version.

 En Verse, une validation se produit lorsque les effets de code d'une expression faillible sont rendus permanents après la réussite de cette expression.  

Une valeur est une information que votre programme utilise pour fonctionner. Les chiffres et le texte sont des exemples de valeurs.

Valeur qui peut être modifiée pendant l'exécution d'un programme. On appelle cette valeur "variable", car elle peut varier.

Parfois, le terme "variable" fait référence aux variables et aux constantes collectivement, mais si les variables et les constantes sont similaires, elles présentent une différence importante : la valeur d'une constante ne peut pas être modifiée pendant l'exécution d'un programme.

La syntaxe de base d'une variable est var name : type = value. var est un mot-clé qui indique qu'il s'agit d'une variable, et name correspond au nom que vous attribuez à la variable (appelé identifiant). Le signe : indique qu'un type va être spécifié. Le signe = indique qu'une valeur va être spécifiée, suivie de la valeur proprement dite. Par exemple :

PlayerSpeed : float = 2.0

Cela indique que PlayerSpeed a une valeur de 2,0, représentée par une valeur décimale qui ne change pas pendant l'exécution du programme.

Le nom et le type correspondent à la déclaration, et l'initialisation au moment où cette valeur est exprimée. Il n'est pas nécessaire, bien que ce soit recommandé, d'attribuer une valeur à une variable lors de son initialisation.

Les variables diffèrent des constantes dans la mesure où vous pouvez modifier la valeur d'une variable à tout moment. Pour cela, utilisez une expression d'assignation.

Comparez cette définition à constante. Consultez également la définition d'ensemble.

Cet effet indique que la même entrée dans la fonction ne produit pas toujours la même sortie. L'effet varies indique également qu'il n'est pas garanti que le comportement de la fonction reste le même avec les nouvelles versions de son paquet contenant.

Paramètre limitant la quantité d'informations supplémentaires affichées lorsqu'un journal est généré.

Verse est un langage de programmation à vérification statique mettant l'accent sur la programmation de gameplay.

Voir chemin.

Type de langage de programmation dans lequel le programmeur utilise des éléments visuels en les faisant glisser et en les reliant à d'autres éléments pour réaliser une séquence spécifique d'instructions de programme.

Visual Studio Code, également appelé VS Code, est un éditeur de code source créé par Microsoft pour Windows, Linux et macOS.

Voir langage de programmation visuel.

Méthode de numérotation dans laquelle le premier élément d'une séquence est attribué à 0 plutôt qu'à 1. La position zéro d'un index représente donc 1, la première position représente 2, etc. Les séquences de numérotation qui commencent à 0 sont courantes en mathématiques. En programmation, cette première position dans une matrice est parfois appelée position zéro.