Modèle de stand-up

Ce tutoriel accompagne le modèle Verse de stand-up, qui explique comment utiliser les appareils permettant de créer une expérience cinématique et de réseaux sociaux au sein d'un comedy club :

• Comment utiliser des ressources détaillées de MetaHuman Animator à l'aide des appareils de personnage

• Comment déclencher des événements de jeu lorsqu'un joueur appuie sur une commande à l'aide d'appareils Déclencheur de commande

• Comment asseoir un joueur de manière à lui faire vivre l'expérience à l'aide de l'appareil Siège

Un appareil Verse gère le spectacle, et les principaux concepts du code Verse sont expliqués ci-dessous.

Le modèle Verse de stand-up se trouve dans la section Exemples de fonctionnalités de l'UEFN (Unreal Editor pour Fortnite).

Appareils utilisés :

• 1 chaise

• 4 déclencheurs de commande

• 4 personnages

• 6 séquences cinématiques

Voici les concepts Verse utilisés dans ce tutoriel :

• Abonnements

• Instructions If

• Matrices

• Séquences cinématiques

• API d'appareil Siège

• API de déclencheur de commande

Paramètres de l'île

Voici les paramètres de l'île modifiés pour le modèle Verse Stand-Up :

Siège

Au moment où le joueur entre dans le comedy club, il voit un siège qui fait face à une scène éclairée. Il est invité à s'asseoir sur ce siège. L'installation sur le siège maintient le joueur en place et déclenche une série d'événements qui lui fera vivre le reste de l'expérience.

Les options utilisateur modifiées de l'appareil Siège sont les suivantes :

Appareils Déclencheur de commande

Le déclencheur de commande est le compagnon inséparable de l'appareil Siège. Il lie les entrées du joueur à diverses actions déclenchées chaque fois que le joueur appuie sur le bouton associé. Les déclencheurs d'entrée sont configurés pour autoriser le joueur à changer les caméras au fur et à mesure que le spectacle se déroule.

L'appareil propose douze entrées à sélectionner. Une fois une entrée choisie, vous pouvez ajouter une description d'ATH afin d'expliquer son effet.

Les options utilisateur modifiées de cet appareil sont les suivantes. Chaque appareil possède une liaison et une description d'ATH différentes dans la mesure où il est lié à un appareil de séquence cinématique distinct.

Appareils de personnage

Les appareils de personnage vous permettent d'interagir directement avec le joueur ou avec les autres personnages d'une scène. Ce modèle utilise quatre personnages qui alternent au cours du programme scénique.

Les options utilisateur modifiées de l'appareil de personnage sont les suivantes :

Le personnage principal est assis sur un escalier en coulisse, et les autres personnages attendent dans une petite pièce, au fond.

Essayez différentes tenues de personnage dans le menu déroulant Personnage, pour voir ce qu'elles donnent sur scène.

Appareils de séquence cinématique

Les six appareils de séquence cinématique permettent au joueur de regarder le spectacle de divers points de vue tout en restant assis sur l'appareil Siège.

Cette page n'explique pas en détail comment créer des séquences cinématiques. Pour en savoir plus, rendez-vous sur la page Sequencer et Control Rig, et pour une compréhension approfondie, consultez le document Comment créer des films dans l'Unreal Engine.

La seule modification concernée par cet appareil est la séquence cinématique chargée.

Comment Verse gère le spectacle

Ce modèle utilise Verse pour lancer le spectacle lorsque le joueur s'assied sur l'appareil Siège, ainsi que pour faire passer la caméra en mode TV, un type de vue cinématique. Il permet aussi au joueur de passer d'une caméra à une autre et de repasser en mode TV ou en vue libre pour changer de point de vue.

Créez un nouvel appareil Verse dans votre projet appelé show_template_device.verse à l'aide de l'explorateur Verse et faites glisser l'appareil dans le modèle. Double-cliquez sur votre fichier Verse pour l'ouvrir dans Visual Studio Code.

Dans votre modèle, vous avez configuré des appareils qui participent au fonctionnement de votre spectacle et vous allez maintenant les référencer dans votre code.

Ajoutez les champs suivants au fichier show_template_device :

1. D'abord, au-dessus de la définition de la classe show_template_device, ajoutez un log_channel nommé log_show_template_device.

   Verse

        # Create a custom log channel for the show_template_device. This helps with log filtering in complex games with lots of log sources.
        log_show_template_device := class(log_channel){}
   		
        # A Verse-authored creative device that can be placed in a level
        show_template_device := class(creative_device):
   

   Copy full snippet(5 lines long)

2. À présent, en haut de la définition de la classe show_template_device, ajoutez un enregistreur qui utilise le canal log_show_template_device, afin de savoir quelles instructions Print() proviennent de cet appareil.

   Verse

        # A Verse-authored creative device that can be placed in a level
        show_template_device := class(creative_device):
   		
            # Logger that uses custom log channel.
            Logger:log = log{Channel := log_show_template_device}
   

   Copy full snippet(5 lines long)

3. Un appareil de chaise modifiable nommé TheChair. Il s'agit du siège dans lequel s'assied le joueur pour lancer le spectacle.

   Verse

        # The chair device the player should sit in.
        @editable
        TheChair:chair_device = chair_device{}
   

   Copy full snippet(3 lines long)

4. Deux appareils de séquence cinématique modifiables nommés MainSequence et TVModeSequence. MainSequence est la séquence cinématique qui gère le spectacle par pilotage de l'animation et de l'audio de l'appareil de personnage du niveau. Avec TVModeSequence, la caméra du joueur adopte un mode de vue conforme à MainSequence, qui permet d'alterner entre plusieurs angles.

   Verse

        # The sequence that drives animation and audio on the character device in the level.
        @editable
        MainSequence:cinematic_sequence_device = cinematic_sequence_device{}
        # The sequence that drives the TV mode sequence for viewing in the level.
        @editable
        TVModeSequence:cinematic_sequence_device = cinematic_sequence_device{}
   

   Copy full snippet(6 lines long)

5. Une matrice modifiable de cinematic_sequence_device nommée CameraSwitches. Cette matrice détient des références à chacune des caméras auxquelles les joueurs peuvent passer pendant le spectacle.

   Verse

        # A list of alternative camera sequences that are provided to view from during the main sequence.
        @editable
        CameraSwitches:[]cinematic_sequence_device = array{}
   

   Copy full snippet(3 lines long)

6. Quatre appareils input_trigger_devicemodifiables. Chacun de ces appareils reçoit les entrées de joueur pour passer d'un mode de caméra à un autre. Le déclencheur ReturnToFreeLook renvoie le joueur à la caméra par défaut, tandis que ReturnToTVMode le renvoie au TVModeSequence. Les caméras NextCamera et PreviousMode lui permettent de passer d'une séquence cinématique à une autre dans la matrice CameraSwitches.

   Verse

        # An input trigger that will return us to free look while in the chair.
        @editable
        ReturnToFreeLook:input_trigger_device = input_trigger_device{}
   		
        # An input trigger that will return us to TV mode when appropriate in the chair.
        @editable
        ReturnToTVMode:input_trigger_device = input_trigger_device{}
   		
        # An input trigger that will choose the next camera while in the chair.
        @editable
   
   Expand code Copy full snippet(15 lines long)

7. Une variable facultative d'appareil de séquence cinématique nommée CurrentSequence. Si une séquence cinématique comme TVModeSequence est en cours de lecture, cette option en stocke une référence. Il n'est pas souhaitable de lire plusieurs séquences cinématiques à la fois pour le personnage, et vous pouvez donc utiliser cette option pour désactiver la séquence en cours lorsque vous passez à une nouvelle.

   Verse

        # The alternative camera sequence that is playing if valid.
        var CurrentSequence:?cinematic_sequence_device = false
   

   Copy full snippet(2 lines long)

8. Deux variables logiques nommées MainSequencePlaying et InTvMode. Elles vous informent respectivement de la lecture de MainSequence ou TVModeSequence.

   Verse

        # Helps us track when the main sequence on the character device is playing.
        var MainSequencePlaying:logic = false
   		
        # When we are in TV mode.
        var InTVMode:logic = false
   

   Copy full snippet(5 lines long)

9. Une variable int nommée CurrentCameraIndex. Elle suit l'index de la séquence cinématique dans la matrice CameraSwitches en cours de lecture.

   Verse

        # Keeps track of what camera we are viewing when using other cameras besides TV Mode.
        var CurrentCameraIndex:int = -1
   

   Copy full snippet(2 lines long)

10. Cinq variables cancelable (annulables) facultatives qui suivent les abonnements pour tous les événements référencés dans ce modèle. Diverses fonctions doivent être exécutées lorsque le joueur passe d'une caméra à une autre, revient en vue libre ou en mode TV, ou quitte l'appareil Siège. Un peu plus loin dans ce tutoriel, vous allez abonner les fonctions aux événements qui les déclenchent et stocker une référence à chaque abonnement de manière à pouvoir l'annuler lorsqu'il n'est plus nécessaire.

    Verse

         # Subscriptions to all the events we listen for while running.
         var ReturnToFreeLookSubscription:?cancelable = false
         var NextCameraSubscription:?cancelable = false
         var PrevCameraSubscription:?cancelable = false
         var ReturnToTVModeSubscription:?cancelable = false
         var ChairExitSubscription:?cancelable = false
    

    Copy full snippet(6 lines long)

11. Enregistrez le script dans Visual Studio Code et compilez-le pour mettre à jour votre appareil créé avec Verse dans le niveau.

12. Sélectionnez l'appareil show_template_device dans votre modèle. Dans le panneau Détails, attribuez chaque référence d'appareil de votre script à l'appareil associé dans le niveau, notamment chacun de vos déclencheurs de commande et chacune de vos séquences cinématiques.

    

Déclencher la séquence

Le spectacle commence par une séquence cinématique une fois le joueur assis sur l'appareil Siège. Suivez les étapes ci-dessous pour déclencher la séquence principale lorsqu'un joueur s'assied sur le siège et pour lancer le mode TV afin que le joueur puisse regarder.

1. Ajoutez une nouvelle fonction RunSequence() à la classe show_template_device. Cette fonction prend l'agent qui a démarré le spectacle et démarre à la fois MainSequence et TVModeSequence. Ajoutez le modificateur à RunSequence() pour une exécution asynchrone. Cette fonction doit être asynchrone pour que vous puissiez exécuter d'autres codes simultanément et permettre au joueur de passer d'un angle de vue à un autre sans interrompre le code RunSequence().

   Verse

        # Handles running the main sequence which runs the character and TV mode sequences for viewing and then calls a function to await finishing.
        RunSequence(Agent:agent)<suspends>:void =

   Copy full snippet(2 lines long)

2. Dans RunSequence(), appelez Sleep() pendant une seconde pour laisser s'achever l'animation du joueur s'asseyant sur le siège avant de lancer le spectacle. Appelez ensuite Play() sur la MainSequence et définissez MainSequencePlaying sur true.

   Verse

        # Sleep for a second because we just entered the chair and the animation to sit takes a moment.
        Sleep(1.0)
   		
        # Run the Main sequence on the character device and the TV mode viewing sequence.
        Logger.Print("Main Sequence Playing")
        set MainSequencePlaying = true
        MainSequence.Play()
   

   Copy full snippet(7 lines long)

3. Appelez Play() sur TVModeSequence en faisant passer la caméra de l'agent qui a lancé le spectacle en vue cinématique. Activez InTVMode et appelez une nouvelle fonction intitulée AwaitMainSequenceEnding() qui attend la fin de la MainSequence en transmettant l'agent. Vous configurerez cette fonction à la prochaine étape. Votre code RunSequence() doit ressembler à ce qui suit une fois terminé :

   Verse

        # Handles running the main sequence which runs the character and TV mode sequences for viewing and then calls a function to await finishing.
        RunSequence(Agent:agent)<suspends>:void =
   
            # Sleep for a second because we just entered the chair and the animation to sit takes a moment.
            Sleep(1.0)
   
            # Run the Main sequence on the character device and the TV mode viewing sequence.
            Logger.Print("Main Sequence Playing")
            set MainSequencePlaying = true
            MainSequence.Play()
   
   Expand code Copy full snippet(16 lines long)

4. Ajoutez une nouvelle fonction AwaitMainSequecingEnding() à la classe show_template_device qui prend l'agent depuis RunSequence(). Cette fonction a elle aussi besoin du modificateur <suspends>, car il est souhaitable qu'elle s'exécute en arrière-plan et se déclenche à la fin de MainSequence.

   Verse

        # When the main sequence finishes, we clear the flag so that if the player sits back down, it will play again.
        AwaitMainSequencingEnding(Agent:agent)<suspends>:void =

   Copy full snippet(2 lines long)

5. Dans AwaitMainSequencingEnding(), appelezAwait() sur MainSequence.StoppedEvent(). À la fin de MainSequence, désactivez MainSequencePlaying en le définissant sur false et expulsez le joueur du siège à l'aide de la fonction Eject() du siège. Votre fonction AwaitMainSequencingEnding() doit ressembler à ce qui suit une fois terminée :

   Verse

        # When the main sequence finishes, we clear the flag so that if the player sits back down, it will play again.
        AwaitMainSequencingEnding(Agent:agent)<suspends>:void =
            MainSequence.StoppedEvent.Await()
            Logger.Print("Main Sequence Ended")
            set MainSequencePlaying = false
   
            # Kick the player out of the chair after the performance
            TheChair.Eject(Agent)

   Copy full snippet(8 lines long)

6. Ajoutez les nouvelles fonctions DoReturnToTVMode() et DoReturnToFreeLook() à la classe show_template_device. Ces fonctions gèrent la logique lorsqu'un joueur revient respectivement en mode TV ou en vue libre, mais laissez-les vides pour le moment ; vous les remplirez lors d'une prochaine étape.

   Verse

        # Returns us to our TV viewing mode sequence by checking where the main sequence is and aligning our playback to that point.
        DoReturnToTVMode(Agent:agent):void =
            Logger.Print("Return to TV Mode")
   		
        # Determine if we are in TV mode or another camera sequence and return control to the main player camera.
        DoReturnToFreeLook(Agent: agent):void =
            Logger.Print("Return to Free Look")
   

   Copy full snippet(7 lines long)

7. Ajoutez une nouvelle fonction OnSeated() à la classe show_template_device qui prend l'agent qui s'est assis sur TheChair.

   Verse

        # This function handles the player sitting down and starting up the performance if it isn't already running and setting up the input triggers.
        OnSeated(Agent:agent):void =
            Logger.Print("Player sat down")
   

   Copy full snippet(3 lines long)

8. Dans OnSeated(), si la MainSequence n'est pas déjà en cours de lecture, générez une fonction RunSequence() en transmettant l'agent qui s'est assis sur l'appareil Siège. Sinon, appelez DoReturnToTVMode() avec le même agent.

   Verse

        # This function handles the player sitting down and starting up the performance if it isn't already running and setting up the input triggers.
        OnSeated(Agent:agent):void =
            Logger.Print("Player sat down")
   		
            # If the main sequence is not playing on the character device in the level, run it, otherwise if it is running then just return to the TV mode viewing experience.
            if (MainSequencePlaying = false):
                spawn{RunSequence(Agent)}
            else:
                DoReturnToTVMode(Agent)
   

   Copy full snippet(9 lines long)

9. Ajoutez une nouvelle fonction OnChairExited() à la classe show_template_device qui prend le joueur ayant quitté le siège. Vous remplirez la logique de cette fonction à une étape ultérieure.

   Verse

        # Handles the player leaving the chair and removing access to the input triggers that are available while in the chair.
        OnChairExited(Agent:agent):void =
            Logger.Print("Player got up")
   

   Copy full snippet(3 lines long)

10. Dans OnBegin(), abonnez TheChair.SeatedEvent à la fonction OnSeated(). Désormais, chaque fois qu'un joueur s'assied dans TheChair, le spectacle s'exécute.

    Verse

         # Runs when the device is started in a running game.
         OnBegin<override>()<suspends>:void =
             Logger.Print("Standup Template device started")
             TheChair.SeatedEvent.Subscribe(OnSeated)

    Copy full snippet(4 lines long)

Enregistrez le script dans Visual Studio Code, compilez-le, puis cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester le modèle. Lorsque vous exécutez votre jeu, l'installation sur le siège doit lancer le spectacle et placer la caméra du joueur en mode cinématique. Une fois le spectacle terminé, le joueur doit être expulsé du siège.

Changer de caméra

Pendant le spectacle, le joueur assis sur TheChair peut passer de l'un à l'autre des divers points de vue, gérés par les différentes séquences cinématiques. Suivez les étapes ci-dessous pour configurer la logique de passage de l'une à l'autre de ces différentes séquences.

1. Ajoutez une nouvelle fonction DoCameraSwitch() à la classe show_template_device. Cette fonction prend l'agent dont vous adoptez la caméra, ainsi qu'un int correspondant à l'index de séquence cinématique dans CameraSwitches.

   Verse

        # Switches us between camera sequences that have been specified by stopping any current ones and moving to the next appropriate one on the list.
        DoCameraSwitch(Agent:agent, Value:int):void =
   

   Copy full snippet(2 lines long)

2. Dans DoCameraSwitch(), dans une instruction if, obtenez la séquence cinématique à l'index Valeur de la matrice CameraSwitches. Arrêtez ensuite toute séquence de lecture en cours en vérifiant si CurrentSequence contient une séquence cinématique et en appelant Stop() dessus.

   Verse

        # Switches us between camera sequences that have been specified by stopping any current ones and moving to the next appropriate one on the list.
        DoCameraSwitch(Agent:agent, Value:int):void =
            if (CameraSwitch := CameraSwitches[Value]):
                Logger.Print("Switching Cameras to {Value}")
   		
                # Stop any currently playing other camera sequence.
                if (PlayingSequence := CurrentSequence?):
                    PlayingSequence.Stop(Agent)
   

   Copy full snippet(8 lines long)

3. Commencez à lire la nouvelle séquence cinématique en appelant Play() sur CameraSwitch. Définissez ensuite CurrentSequence de manière à indiquer quelle séquence est en cours de lecture. Enfin, à l'aide de Register, inscrivez l'agent dont vous adoptez la caméra auprès des déclencheurs de commande ReturnToTVMode et ReturnToFreeLook pour leur permettre de revenir à ces modes lors du suivi d'autres caméras. Votre fonction DoCameraSwitch() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Switches us between camera sequences that have been specified by stopping any current ones and moving to the next appropriate one on the list.
        DoCameraSwitch(Agent:agent, Value:int):void =
            if (CameraSwitch := CameraSwitches[Value]):
                Logger.Print("Switching Cameras to {Value}")
   		
                # Stop any currently playing other camera sequence.
                if (PlayingSequence := CurrentSequence?):
                    PlayingSequence.Stop(Agent)
   		
                # Start up the new camera viewing sequence.
   
   Expand code Copy full snippet(16 lines long)

4. Pour passer à la caméra suivante ou à la caméra précédente, vous allez configurer DoNextCamera() et DoPreviousCamera(), deux fonctions très semblables. Vous devez tout d'abord remplir la logique de la caméra suivante ; par conséquent, ajoutez une nouvelle fonction DoNextCamera() à la classe show_template_device. Cette fonction prend l'agent dont vous adoptez la caméra.

   Verse

        # Switches to the next camera on our list, or the first if we are in TV mode.
        DoNextCamera(Agent:agent):void =
            Logger.Print("Next Camera")
   

   Copy full snippet(3 lines long)

5. Dans DoNextCamera(), vérifiez si le joueur est actuellement en mode TV. Si c'est le cas, arrêtez la TVModeSequence avec Stop(), puis définissez InTVMode sur false et CurrentCameraIndex sur -1. -1 est utilisé ici parce qu'il est souhaitable d'indexer la matrice CameraSwitches, qui correspondrait à l'index 0, dans la séquence cinématique suivante.

   Verse

        # If we are currently viewing from TV Mode, end that sequence and clear associated values.
        if (InTVMode?):
            TVModeSequence.Stop(Agent)
            set InTVMode = false
            set CurrentCameraIndex = -1
   

   Copy full snippet(5 lines long)

6. Vous devez ensuite déterminer la caméra suivante à utiliser en fonction de l'index de la caméra actuelle. Pour ce faire, ajoutez une nouvelle variable NextCameraValue au Mod de CurrentCameraIndex + 1 et CameraSwitches.Length. Cela vous permet de fixer NextCameraValue sur une valeur comprise entre 0 et la longueur de CameraSwitches et vous empêche d'obtenir une NextCameraValue située hors de la matrice CameraSwitches. Une fois votre NextCameraValue obtenue, attribuez CurrentCameraValue à NextCameraValue et appelez DoCameraSwitch() en transmettant l'agent et le CurrentCameraIndex. Votre fonction DoNextCamera() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Switches to the next camera on our list, or the first if we are in TV mode.
        DoNextCamera(Agent:agent):void =
            Logger.Print("Next Camera")
   		
            # If we are currently viewing from TV Mode, end that sequence and clear associated values.
            if (InTVMode?):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
                set CurrentCameraIndex = -1
   		
   
   Expand code Copy full snippet(14 lines long)

7. Pour passer à la caméra précédente, ajoutez une nouvelle fonction nommée DoPreviousCamera() à la classe show_template_device. Copiez le code de DoNextCamera() dans cette fonction. Lorsque vous vérifiez si le joueur est en mode TV, définissez CurrentCameraIndex sur 0 au lieu de -1. Modifiez également NextCameraValue pour qu'elle corresponde au Mod de CurrentCameraIndex - 1 et CameraSwitches.Length. Votre fonction DoPreviousCamera() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Switches us to the previous camera on the list or last camera if we are leaving TV mode.
        DoPreviousCamera(Agent:agent):void =
            Logger.Print("Prev Camera")
   		
            # If we are currently viewing from TV Mode, end that sequence and clear associated values.
            if (InTVMode?):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
                set CurrentCameraIndex = 0
   		
   
   Expand code Copy full snippet(14 lines long)

Lorsqu'un joueur est assis dans TheChair et qu'il suit une autre caméra dans CameraSwitches, il peut revenir en mode TV ou en vue libre. Vous avez précédemment configuré les fonctions DoReturnToFreeLook() et DoReturnToTVMode() et devez à présent les remplir.

1. Dans la fonction DoReturnToFreeLook(), vérifiez si le joueur est actuellement en mode TV. Si c'est le cas, arrêtez la TVModeSequence avec Stop() et désactivez InTVMode en le définissant sur false. Procédez de la même façon avec CurrentSequence, en vérifiant si CurrentSequence contient une séquence cinématique et en appelant Stop() et en la désactivant à l'aide de false si tel est le cas.

   Verse

        # If TV Mode is active, stop it.
        if (InTVMode?):
            TVModeSequence.Stop(Agent)
            set InTVMode = false
   		
        # If we are playing another viewing experience, stop it.
        if (TempSeq := CurrentSequence?):
            TempSeq.Stop(Agent)
            set CurrentSequence = false
   

   Copy full snippet(9 lines long)

2. À présent, inscrivez l'agent auprès du déclencheur de commande ReturnToTVMode à l'aide de Register() et désinscrivez-le du déclencheur ReturnToFreeLook à l'aide de Unregister(), puisque vous ne souhaitez pas faire revenir en vue libre un joueur qui s'y trouve déjà. Votre fonction DoReturnToFreeLook() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Determine if we are in TV mode or another camera sequence and return control to the main player camera.
        DoReturnToFreeLook(Agent: agent):void =
            Logger.Print("Return to Free Look")
   		
            # If TV Mode is active, stop it.
            if (InTVMode?):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
   		
            # If we are playing another viewing experience, stop it.
   
   Expand code Copy full snippet(17 lines long)

3. La fonction DoReturnToTVMode() requiert davantage de logique, puisque le retour en mode TV nécessite le démarrage de la TVModeSequence lorsque la MainSequence se produit. D'abord, vérifiez si le joueur est déjà en mode TV lorsque cette fonction est appelée. Si tel est le cas, utilisez return, car il n'y a rien de particulier à faire. Vérifiez ensuite si CurrentSequence contient une séquence cinématique, en appelant Stop() et en la définissant sur false si tel est le cas.

   Verse

        # If we are already in TV mode no need to return to it.
        if (InTVMode?):
            return
   		
        # If we have another camera sequence playing, stop it and clear associated values.
        if (TempSeq := CurrentSequence?):
            TempSeq.Stop(Agent)
            set CurrentSequence = false
   

   Copy full snippet(8 lines long)

4. Vous devez maintenant déterminer à quel endroit de sa lecture se situe la MainSequence et démarrer la TVModeSequence à partir de cet emplacement. Obtenez la durée de lecture de MainSequence en appelant GetPlayBackTime() et enregistrez-la dans une variable CurrentSeekTime. Définissez la durée de lecture de TVModeSequence sur CurrentSeekTime à l'aide de SetPlaybackTime(), et lisez la séquence à l'aide de Play() en transmettant l'agent. Activez ensuite InTVMode en le définissant sur true.

   Verse

        # Figure out where the main sequence is in its playback and start up the TV mode sequence at the same spot to provide the proper viewing experience.
        CurrentSeekTime := MainSequence.GetPlaybackTime()
        TVModeSequence.SetPlaybackTime(CurrentSeekTime)
        TVModeSequence.Play(Agent)
        set InTVMode = true
   

   Copy full snippet(5 lines long)

5. Enfin, désinscrivez l'agent du déclencheur de commande ReturnToTVMode à l'aide de Unregister() et inscrivez-le auprès du déclencheur ReturnToFreeLook à l'aide de Register(). Votre fonction DoReturnToTVMode() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Returns us to our TV viewing mode sequence by checking where the main sequence is and aligning our playback to that point.
        DoReturnToTVMode(Agent:agent):void =
            Logger.Print("Return to TV Mode")
   		
            # If we are already in TV mode no need to return to it.
            if (InTVMode?):
                return
   		
            # If we have another camera sequence playing, stop it and clear associated values.
            if (TempSeq := CurrentSequence?):
   
   Expand code Copy full snippet(22 lines long)

Tout relier

Vous avez configuré beaucoup de fonctions dans la partie précédente de ce tutoriel et le moment est venu de les relier aux divers déclencheurs d'entrée qui les appellent.

1. Dans OnSeated(), à l'aide de Register(), inscrivez l'agent auprès des déclencheurs de commande ReturnToFreeLook, NextCamera, et PreviousCamera, puisqu'il s'agit des déclencheurs auxquels le joueur aura d'emblée accès lorsqu'il s'installera sur le siège. Définissez ensuite ReturnToFreeLookSubscription, NextCameraSubscription et PreviousCameraSubscription en abonnant chaque déclencheur de commande à sa fonction associée. Définissez ReturnToTVModeSubscription et ChairExitSubscription de la même manière.

   Verse

        # Register for the input trigger for free look and subscribe to the pressed event when sitting.
        ReturnToFreeLook.Register(Agent)
        set ReturnToFreeLookSubscription = option{ReturnToFreeLook.PressedEvent.Subscribe(DoReturnToFreeLook)}
   		
        # Register for the input trigger for the next camera and subscribe to the pressed event when sitting.
        NextCamera.Register(Agent)
        set NextCameraSubscription = option{NextCamera.PressedEvent.Subscribe(DoNextCamera)}
   		
        # Register for the input trigger for the previous camera and subscribe to the pressed event when sitting.
        PreviousCamera.Register(Agent)
   
   Expand code Copy full snippet(17 lines long)

2. Ajoutez une nouvelle fonction CancelSubscription() qui prend une valeur cancelable facultative à la classe show_template_device. Dans CancelSubscription(), assurez-vous que Subscription contient une valeur. Si tel est le cas, annulez l'abonnement avec Cancel(). Votre annulation d'abonnement CancelSubscription() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Cancel a subscription if it is valid.
        CancelSubscription(Subscription:?cancelable):void =
            if (SubscriptionToCancel := Subscription?):
                SubscriptionToCancel.Cancel()
   

   Copy full snippet(4 lines long)

3. Lorsqu'un joueur quitte le siège, vous devez arrêter toute séquence en cours de lecture sur le joueur et annuler tout abonnement aux déclencheurs d'entrée auquel le joueur était inscrit. À la fonction OnChairExited(), comme dans DoReturnToFreeLook(), assurez-vous que le joueur est en mode TV et que CurrentSequence contient une séquence cinématique. Appelez Stop() sur chaque séquence si c'est le cas et désactivez InTVMode en le définissant sur false si le joueur se trouve en mode TV. Désactivez ensuite CurrentSequence en la définissant sur false.

   Verse

        # Stop the TV camera view when we leave the chair if it is active.
        if (InTVMode = true):
            TVModeSequence.Stop(Agent)
            set InTVMode = false
   		
        # Stop the camera sequence we were using if it is active when we leave the chair.
        if (TempSeq := CurrentSequence?):
            TempSeq.Stop(Agent)
   		
        # Clear whatever the current sequence was when we leave the chair.
   
   Expand code Copy full snippet(11 lines long)

4. À présent, annulez tous les abonnements du joueur en transmettant chacun d'eux à la fonction CancelSubscription(). Désinscrivez également le joueur de chaque déclencheur de commande grâce à Unregister(), puisqu'il ne doit plus avoir accès à ces boutons lorsqu'il quitte le siège. Votre fonction OnChairExited() doit ressembler à ce qui suit une fois terminée :

   Verse

        # Handles the player leaving the chair and removing access to the input triggers that are available while in the chair.
        OnChairExited(Agent:agent):void =
            Logger.Print("Player got up")
   		
            # Stop the TV camera view when we leave the chair if it is active.
            if (InTVMode = true):
                TVModeSequence.Stop(Agent)
                set InTVMode = false
   		
            # Stop the camera sequence we were using if it is active when we leave the chair.
   
   Expand code Copy full snippet(28 lines long)

Enregistrez le script dans Visual Studio Code, compilez-le, puis cliquez sur Lancer la session dans la barre d'outils de l'UEFN pour tester le modèle. Au moment du test, le fait de s'asseoir sur le siège doit déclencher le spectacle. Pendant le spectacle, vous devez pouvoir alterner entre mode TV, vue libre et les autres angles de caméra. Repasser en mode TV doit aligner la séquence en mode TV sur la séquence principale. À la fin du spectacle, vous devez repasser en vue libre et quitter le siège.