Case

Avec les expressions case, vous pouvez contrôler le flux d'un programme à partir d'une liste de choix. L'instruction case dans Verse est un moyen de tester une valeur par rapport à plusieurs valeurs possibles (comme si vous utilisiez =), et d'exécuter du code en fonction de celle qui correspond.

L'utilisation des expressions case se retrouve dans toutes sortes d'applications, comme dans les jeux comportant un personnage non-joueur (PNJ).

Par exemple, imaginons que vous utilisiez l'appareil Générateur de gardes pour faire apparaître un garde dont l'option de patrouille est activée. Une fois le garde apparu dans le jeu, il a plusieurs états actifs possibles, notamment Immobile, Patrouille, Alerte, Attaque et Récolte. Un diagramme de transition d'état de haut niveau pourrait ressembler à ceci :

Vous pouvez observer ces transitions d'état dans le jeu.

Dans cette vidéo, le garde a son option de patrouille activée comme comportement par défaut.

Dans la vidéo, le garde passe de la patrouille de la base scientifique à la récolte de certaines ressources. Ensuite, le garde repère le joueur, ce qui le met en état d'alerte (indiqué par le point d'interrogation flottant) avant d'entrer en état d'attaque (indiqué par le point d'exclamation flottant).

Selon l'état dans lequel se trouve le garde, il adopte certains comportements, et ces comportements sont généralement codés en tant que fonctions qui sont appelées lorsque le programme choisit d'entrer dans un état spécifique.

En code, cette transition d'état de garde de haut niveau pourrait ressembler à ceci :

case(GuardStateVariable):
        idle_state =>
            RunIdleAnimation()
            SearchPlayerCharacter()
        harvest_state =>
            GatherResources()
        alert_state=>
            RunAlertAnimation()
            PlayAlertSound()
            DisplayAlertUIElement()

Cette expression case transmet une balise qui indique au programme les fonctions à exécuter si le garde entre dans un état spécifique.

Dans cette expression, le patrol_state du garde est l'expression case par défaut, car un garde dont la patrouille est activée doit exécuter son comportement de patrouille par défaut.

D'un point de vue syntaxique, cela équivaut à :

expression0
    case (test-arg-block):
    label1 =>
        expression1
    label2 =>
        expression2
    _ =>
        expression3 for the default case
    expression4

Chaque motif du bloc case, tel que label1 et label2, doit utiliser la forme constant => block, où constant peut être une constante integer, logic, string, char ou enum. Les instructions case ne fonctionnent donc qu'avec int, logic, string, char et les énumérations.

Structure

D'un point de vue structurel, l'expression case de Verse exécute du code basé sur l'entrée du bloc d'arguments de test GuardStateVariable, et fonctionne de la même manière qu'une série d'expressions if.

Dans cet exemple, le programme Verse exécute expression3 si GuardStateVariable se résout en alert_state. Si le programme passe à l'état patrol_state, Verse passe structurellement à l'expression case par défaut et exécute expression5.

Utiliser l'instruction case avec d'autres flux de contrôle

Les blocs d'une instruction case sont autorisés à s'interrompre et se poursuivre si l'instruction se trouve à l'intérieur d'une boucle (loop). Les blocs d'instructions « case » sont également autorisés à revenir de la fonction dans laquelle ils se trouvent.

Par exemple :

loop:
        case (x):
            42 => break
            _ => {}

Cette boucle absurde va soit se terminer immédiatement si x = 42, soit se poursuivre indéfiniment.

Un autre exemple :

Foo(x : int) : int =
        case (x):
            100 => return 200
            _ => return 100

Cet exemple est équivalent à :

Foo(x : int) : int =
        case (x):
            100 => 200
            _ => 100

Cela est dû au fait que l'instruction « case » est la dernière expression de la fonction.

Instruction case par défaut

Les instructions case qui n'ont pas de _=> (expression case par défaut) échouent si aucune des instructions case ne correspond. Il est possible d'utiliser de telles instructions case dans les contextes d'échec (comme les fonctions avec l'effet decides).

Les instructions case qui correspondent à tous les cas d'une énumération sont non défaillantes même si elles n'ont pas d'expression case _=>.