Codage des interactions entre les appareils dans Verse | Fortnite Documentation

Si la liaison d'événements directe vous est familière, sachez que le concept d'événements et de fonctions appliqué aux appareils créatifs est également valable pour Verse. Vous pouvez utiliser Verse pour coder vos propres fonctions et comportements à exécuter lorsque des événements se produisent !

Les sections suivantes décrivent les différentes façons dont vous pouvez travailler avec les événements d'appareil créatif dans Verse et coder votre propre logique.

Lier des fonctions à des événements d'appareil créatif

Vous pouvez vous abonner aux événements exposés par les appareils créatifs dans leur API. Par exemple, la classe button_device de l'appareil Bouton expose InteractedWithEvent, qui se produit chaque fois que le joueur interagit avec l'appareil Bouton. Vous pouvez appeler Subscribe() sur l'événement et transmettre l'identificateur de la fonction que vous souhaitez appeler chaque fois que l'événement est signalé.

Vous abonner vous permet de spécifier une fonction à appeler lorsqu'un événement est signalé. C'est ce que l'on appelle une liaison à un événement. La fonction liée est appelée gestionnaire. Dans l'exemple ci-dessous, le gestionnaire est OnButtonInteractedWith.

Selon la définition de l'événement, la signature de la fonction doit correspondre à ce que l'événement s'attend à appeler. Par exemple, l'abonnement à l'événement InteractedWithEvent pour le button_device s'attend à recevoir une fonction avec un paramètre de type agent. La fonction OnButtonInteractedWith devrait donc ressembler à ceci :

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

hello_world_device := class(creative_device):
    @editable
    MyButtonDevice:button_device = button_device{}

    OnBegin<override>()<suspends>:void=
        # Lier la fonction OnButtonInteractedWith à l'événement InteractedWithEvent de l'appareil Bouton
        MyButtonDevice.InteractedWithEvent.Subscribe(OnButtonInteractedWith)

    OnButtonInteractedWith(InAgent:agent):void=
        Print("Player interacted with button!")

Lorsque vous appelez Subscribe() sur un événement d'appareil, la fonction renvoie un résultat cancelable. L'appel de Cancel() sur une variable cancelable désabonne la fonction qui gère l'événement, de sorte que la fonction n'est plus appelée lorsque l'événement est signalé.

Si vous souhaitez stocker un résultat cancelable unique, vous pouvez utiliser un conteneur tel qu'une option. Vous ne pouvez pas créer directement de variable cancelable, mais vous pouvez configurer une variable option pour maintenir le résultat d'un abonnement.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

spawner_button := class(creative_device):

    @editable
    Button:button_device = button_device{}

    # Conteneur destiné au stockage d'abonnement aux événements
    var ButtonSubscription:?cancelable = false

    OnBegin<override>()<suspends>:void=
        ButtonSubscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith)

        # Définir le résultat annulable comme valeur de la variable d'option.
        set ButtonSubscription = option{Subscription}
        Print("Subscribed to the Button's InteractedWithEvent and assigned the subscription to ButtonSubscription!")

    OnButtonInteractedWith(InPlayer:agent):void=
        Print("Player interacted with button!")

        # Accéder à la variable annulable pour l'abonnement à l'événement InteractedWithEvent
        if(CancelableResult := ButtonSubscription?):
            CancelableResult.Cancel()
            Print("Canceled this InteractedWithEvent")

Si votre appareil Verse a plusieurs abonnements à des événements, il serait judicieux d'utiliser un conteneur comme une matrice pour stocker tous les résultats cancelable de chaque abonnement à un événement, afin que vous puissiez les annuler plus tard. Subscribe() renvoyant un résultat cancelable, vous pouvez définir vos valeurs de matrice cancelable à votre premier abonnement à des événements.

Exemple d'objet qui apparaît lorsque le joueur appuie sur un bouton

Le générateur d'objets génère un objet lorsque le joueur interagit avec le bouton

Dans cette section, vous apprendrez à créer un générateur d'objets qui fait apparaître son objet lorsque le joueur interagit avec un bouton.

Commencez par placer un appareil générateur d'objets et un appareil Bouton dans votre niveau. Pour en savoir plus sur le placement d'appareils dans votre niveau, consultez la section Placer des objets de la rubrique Contrôles de l'UEFN pour les utilisateurs du mode Créatif.
Définissez l'objet qui sera généré par le générateur d'objets. Consultez la rubrique générateur d'objets pour plus d'informations.
Créez un appareil Verse avec une propriété modifiable pour l'appareil Bouton et une autre pour le générateur d'objets. Vous pouvez consulter la rubrique Ajouter une référence Verse à un appareil du mode Créatif dans votre niveau.
Ajoutez une variable d'option cancelable à l'appareil pour suivre l'abonnement à l'appareil Bouton.
Abonnez-vous à l'InteractedWithEvent, diffusez le résultat à une option et assignez-le à la variable ButtonSubscription.
Dans le gestionnaire de l'événement InteractedWithEvent, appelez ItemSpawner.SpawnItem(). Annulez ensuite l'abonnement en accédant à la valeur située dans l'option ButtonSubscription et en appelant Cancel().
Voici le code Verse complet pour faire apparaître un objet lorsque le joueur interagit avec l'appareil Bouton. Une seconde interraction avec l'appareil Bouton ne génère pas d'autre objet.
```
 using { /Fortnite.com/Devices }
 using { /Verse.org/Simulation }

 spawner_button := class(creative_device):

    @editable
    Button:button_device = button_device{}

    @editable
    ItemSpawner:item_spawner_device = item_spawner_device{}

    # Conteneur destiné au stockage d'abonnement aux événements
    var ButtonSubscription:?cancelable = false

    OnBegin<override>()<suspends>:void=

        Subscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith)

        # Ajouter le résultat annulable à un emplacement de la matrice Abonnements.
        set ButtonSubscription = option{Subscription}
        Print("Subscribed to the Button's InteractedWithEvent and assigned the subscription to ButtonSubscription!")

    OnButtonInteractedWith(InPlayer:agent):void=
        ItemSpawner.SpawnItem()

        # Accéder à la variable annulable pour l'abonnement à l'événement InteractedWithEvent
        if(CancelableResult := ButtonSubscription?):
            CancelableResult.Cancel()
            Print("Canceled this InteractedWithEvent")
```
using { /Fortnite.com/Devices } using { /Verse.org/Simulation } spawner_button := class(creative_device): @editable Button:button_device = button_device{} @editable ItemSpawner:item_spawner_device = item_spawner_device{} # Conteneur destiné au stockage d'abonnement aux événements var ButtonSubscription:?cancelable = false OnBegin<override>()<suspends>:void= Subscription := Button.InteractedWithEvent.Subscribe(OnButtonInteractedWith) # Ajouter le résultat annulable à un emplacement de la matrice Abonnements. set ButtonSubscription = option{Subscription} Print("Subscribed to the Button's InteractedWithEvent and assigned the subscription to ButtonSubscription!") OnButtonInteractedWith(InPlayer:agent):void= ItemSpawner.SpawnItem() # Accéder à la variable annulable pour l'abonnement à l'événement InteractedWithEvent if(CancelableResult := ButtonSubscription?): CancelableResult.Cancel() Print("Canceled this InteractedWithEvent")
Démarrez votre jeu et interagissez avec le bouton pour faire apparaître un objet. Étant donné que vous avez annulé InteractedWithEvent, le bouton ne doit faire apparaître un objet qu'une seule fois.

Consultez le tutoriel de casse-tête avec séquences de lumières balisées pour un exemple de jeu qui utilise cet abonnement d'appareil et son annulation !

En attente d'un événement d'appareil créatif

Vous pouvez vous abonner à des événements, mais il existe un autre moyen d'attendre qu'un événement se produise. Vous pouvez appeler Await() sur un événement d'appareil créatif, ce qui est un appel de fonction asynchrone et peut prendre du temps. Cela signifie que vous devez l'utiliser dans un contexte asynchrone, comme une expression de concurrence ou une fonction avec le spécificateur suspends. Pour en savoir plus sur la concurrence, consultez la rubrique Aperçu de la concurrence.

Dans l'exemple suivant, l'appareil Verse attend que le joueur interagisse avec le déclencheur avant que quoi que ce soit ne se produise. S'il interagit avec l'un des appareils Bouton avant le déclencheur, rien ne se passera. Après avoir interagi avec le déclencheur, le joueur doit choisir l'un des deux boutons. Il ne peut interagir qu'une seule fois avec l'un des boutons pour que quelque chose se produise, parce que le code utilise une expression race pour passer d'un événement de bouton à l'autre. Pour plus de détails sur le fonctionnement de cette expression de concurrence, consultez Race.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

make_a_choice_device:= class(creative_device):

    @editable
    MakeChoice:trigger_device = trigger_device{}

    @editable
    RedButton:button_device = button_device{}

    @editable
    BlueButton:button_device = button_device{}

    OnBegin<override>()<suspends>:void=
        # Cette opération attend que le joueur marche sur le déclencheur et empêche tout autre code de s'exécuter ici jusqu'à ce que cela se produise.
        # Cela signifie que si le joueur interagit avec les deux appareils Bouton, rien ne se passera avant que cet événement ne se produise.
        MakeChoice.TriggeredEvent.Await()
        Print("Make a choice: red button and stay in wonderland, or blue button and wake up back in your bed.")

        # Les deux expressions de bloc s'exécutent en même temps dans cette expression "race".
        # Lorsque le joueur interagit avec l'un des boutons, l'attente de l'interaction avec l'autre bouton est annulée.
        # Cela signifie que le joueur ne peut interagir qu'avec l'un des appareils Bouton.
        race:
            block:
                RedButton.InteractedWithEvent.Await()
                Print("You chose to stay in wonderland.")
            block:
                BlueButton.InteractedWithEvent.Await()
                Print("You chose to wake up in your bed.")

         # Si le joueur interagit avec l'un des appareils à ce stade, il ne se passera rien, car nous n'avons attendu que les événements se produisent qu'une seule fois.

using { /Fortnite.com/Devices }
using { /Verse.org/Simulation }

make_a_choice_device:= class(creative_device):

@editable
    MakeChoice:trigger_device = trigger_device{}

@editable
    RedButton:button_device = button_device{}

@editable
    BlueButton:button_device = button_device{}

OnBegin<override>()<suspends>:void=
        # Cette opération attend que le joueur marche sur le déclencheur et empêche tout autre code de s'exécuter ici jusqu'à ce que cela se produise.
        # Cela signifie que si le joueur interagit avec les deux appareils Bouton, rien ne se passera avant que cet événement ne se produise.
        MakeChoice.TriggeredEvent.Await()
        Print("Make a choice: red button and stay in wonderland, or blue button and wake up back in your bed.")

# Les deux expressions de bloc s'exécutent en même temps dans cette expression "race".
        # Lorsque le joueur interagit avec l'un des boutons, l'attente de l'interaction avec l'autre bouton est annulée.
        # Cela signifie que le joueur ne peut interagir qu'avec l'un des appareils Bouton.
        race:
            block:
                RedButton.InteractedWithEvent.Await()
                Print("You chose to stay in wonderland.")
            block:
                BlueButton.InteractedWithEvent.Await()
                Print("You chose to wake up in your bed.")

# Si le joueur interagit avec l'un des appareils à ce stade, il ne se passera rien, car nous n'avons attendu que les événements se produisent qu'une seule fois.

Ces événements n'attendent qu'une fois. Si vous souhaitez répéter l'attente de ces événements, vous pouvez utiliser une expression loop pour répéter cette logique autant de fois que vous le souhaitez.

Étape suivante : module Appareils

Vous avez appris à utiliser des générateurs d'objets et des boutons, mais il existe d'autres appareils créatifs auxquels vous pouvez vous abonner depuis votre propre appareil. Ces informations se trouvent dans la référence API de Verse. Accédez au module Appareils pour découvrir tous les appareils du mode Créatif que vous pouvez utiliser dans Verse.