Pizza Pursuit 4 Gérer et afficher le score du Contre-la-montre dans Verse | Fortnite Documentation

Dans cette étape du tutoriel Contre-la-montre : Pizza Pursuit, vous allez apprendre à gérer le score lorsqu'un joueur collecte des objets et les livre, puis à mettre à jour l'interface utilisateur en fonction des scores. Pour en savoir plus sur la création d'une interface utilisateur intégrée au jeu dans Verse, consultez la rubrique Créer une interface utilisateur intégrée au jeu.

Le gestionnaire de score assure le suivi et l'affichage des éléments suivants :

Nombre total de points : représente le nombre total de points marqués par le joueur dans le jeu.
Points en attente : représente les points que le joueur a accumulés jusqu'à maintenant pour la série de collectes actuelle.
Niveau de collecte : représente le niveau de collecte actuel.

L'interface utilisateur du gestionnaire de score s'affiche sur le côté gauche de l'écran.

Créer l'interface utilisateur

Procédez comme suit pour créer l’interface utilisateur du gestionnaire de score dans Verse :

Créez un nouveau fichier Verse vide et nommez-le score_manager.verse.
Créez une nouvelle classe nommée score_manager et ajoutez-y les champs suivants :
- Un agent facultatif nommé MaybePlayer pour stocker une référence au joueur. MaybePlayer<internal> : ?agent = false
- Une interface player_ui facultative nommée MaybePlayerUI pour stocker une référence à l'interface utilisateur du joueur. MaybePlayerUI<internal> : ?player_ui = false
- Un appareil score_manager_device pour stocker une référence à l'appareil Gestionnaire de score avec lequel cette classe est construite. Notez que cette référence n'est pas modifiable, car elle doit être reliée à l'appareil game_coordinator_device créé avec Verse. ScoreManagerDevice<internal> : score_manager_device = score_manager_device{}
- Une variable entière nommée TotalGameScore qui représente tous les points que le joueur a marqués dans le jeu en général. var TotalGameScore<private> : int = 0
- Une variable entière nommée PendingScore qui représente les points que le joueur a actuellement accumulés pour cette série de collectes. var PendingScore<private> : int = 0
- Une variable entière nommée PickupLevel qui représente le niveau de collecte actuel. var PickupLevel<private> : int = 0
Votre définition de classe score_manager doit maintenant être similaire à ce qui suit : score_manager := class: MaybePlayer<internal> : ?agent = false MaybePlayerUI<internal> : ?player_ui = false ScoreManagerDevice<internal> : score_manager_device = score_manager_device{} var TotalGameScore<private> : int = 0 var PendingScore<private> : int = 0 var PickupLevel<private> : int = 0
Créez l'interface utilisateur lors de la création initiale de la classe. Pour ce faire, ajoutez à la définition de classe une expression block qui s'exécutera chaque fois que vous créerez une instance de la classe. Ajoutez les variables suivantes pour générer l'IU :
- Une variable canvas nommée Canvas avec le spécificateur internal pour stocker le widget de zone de dessin personnalisé. var Canvas<internal> : canvas = canvas{}
- Un bloc de texte nommé TotalGameScoreWidget avec le spécificateur internal, pour stocker le widget de texte et afficher tous les points que le joueur a marqués dans le jeu en général, tel que représenté par la variable TotalGameScore. Définissez le texte par défaut du bloc de texte sur la couleur blanche. TotalGameScoreWidget<internal> : text_block = text_block{DefaultTextColor := NamedColors.White}
- Un bloc de texte nommé PendingScoreWidget avec le spécificateur internal, pour stocker le widget de texte et afficher les points que le joueur a accumulés jusqu'à présent pour cet ensemble de collectes, tel que représenté par la variable PendingScore. Définissez le texte par défaut du bloc de texte sur la couleur blanche. PendingScoreWidget<internal> : text_block = text_block{}
- Un bloc de texte nommé PickupLevelWidget avec le spécificateur internal, pour stocker le widget de texte et afficher le niveau de collecte actuel, tel que représenté par la variable PickupLevel. Définissez le texte par défaut du bloc de texte sur la couleur blanche. PickupLevelWidget<internal> : text_block = text_block{}
- Une fonction renvoyant un message nommée TotalGameScoreText qui crée un texte localisable à afficher dans l'interface utilisateur pour indiquer tous les points que le joueur a marqués dans le jeu en général. TotalGameScoreText<localizes>(CurrentTotalGameScore : int) : message = "Total Points: {CurrentTotalGameScore}"
- Une fonction renvoyant un message nommée PendingScoreText qui crée un texte localisable à afficher dans l'interface utilisateur pour indiquer les points que le joueur a accumulés jusqu'à présent pour cet ensemble de collectes. PendingScoreText<localizes>(CurrentPendingScore : int) : message = "Pending Points: {CurrentPendingScore}"
- Une fonction renvoyant un message nommée PickupLevelText qui crée un texte localisable à afficher dans l'interface utilisateur pour indiquer le niveau de collecte actuel. PickupLevelText<localizes>(CurrentPickupLevel : int) : message = "Pickup Level: {CurrentPickupLevel}"
- Ajoutez une expression block qui crée le widget de zone de dessin et positionne le texte empilé verticalement sur la gauche de l'écran. <# Étant donné que la zone de dessin ne sera pas créée pendant la durée de vie du gestionnaire de score, créez-la une fois chaque fois qu'un objet de ce type est créé. #> block: set Canvas = canvas: Slots := array: canvas_slot: Anchors := anchors{Minimum := vector2{X := 0.0, Y := 0.25}, Maximum := vector2{X := 0.0, Y := 0.25} } Offsets := margin{Top := 0.0, Left := 25.0, Right := 0.0, Bottom := 0.0} Alignment := vector2{X := 0.0, Y := 0.0} SizeToContent := true Widget := stack_box: Orientation := orientation.Vertical Slots := array: stack_box_slot: HorizontalAlignment := horizontal_alignment.Left Widget := TotalGameScoreWidget stack_box_slot: HorizontalAlignment := horizontal_alignment.Left Widget := PendingScoreWidget stack_box_slot: HorizontalAlignment := horizontal_alignment.Left Widget := PickupLevelWidget
Le code de votre gestionnaire de score score_manager doit maintenant être similaire à celui-ci : using { /UnrealEngine.com/Temporary/UI } using { /Fortnite.com/UI } using { /Verse.org/Colors } score_manager := class: var Canvas<internal> : canvas = canvas{} TotalGameScoreWidget<internal> : text_block = text_block{DefaultTextColor := NamedColors.White} PendingScoreWidget<internal> : text_block = text_block{DefaultTextColor := NamedColors.White} PickupLevelWidget<internal> : text_block = text_block{DefaultTextColor := NamedColors.White} MaybePlayer<internal> : ?agent = false MaybePlayerUI<internal> : ?player_ui = false ScoreManagerDevice<internal> : score_manager_device = score_manager_device{} PickupLevelText<private><localizes>(InLevel : int) : message = "Pickup Level: {InLevel}" PendingScoreText<private><localizes>(InPoints : int) : message = "Pending Points: {InPoints}" TotalGameScoreText<private><localizes>(InPoints : int) : message = "Total Points: {InPoints}" var TotalGameScore<private> : int = 0 var PendingScore<private> : int = 0 var PickupLevel<private> : int = 0 <# Étant donné que la zone de dessin ne sera pas créée pendant la durée de vie du gestionnaire de score, créez-la une fois chaque fois qu'un objet de ce type est créé. #> block: set Canvas = canvas: Slots := array: canvas_slot: Anchors := anchors{Minimum := vector2{X := 0.0, Y := 0.25}, Maximum := vector2{X := 0.0, Y := 0.25} } Offsets := margin{Top := 0.0, Left := 25.0, Right := 0.0, Bottom := 0.0} Alignment := vector2{X := 0.0, Y := 0.0} SizeToContent := true Widget := stack_box: Orientation := orientation.Vertical Slots := array: stack_box_slot: HorizontalAlignment := horizontal_alignment.Left Widget := TotalGameScoreWidget stack_box_slot: HorizontalAlignment := horizontal_alignment.Left Widget := PendingScoreWidget stack_box_slot: HorizontalAlignment := horizontal_alignment.Left Widget := PickupLevelWidget
Créez une fonction nommée UpdateUI() avec le spécificateur private, qui met à jour le texte dans l'interface utilisateur avec les dernières valeurs de score et le niveau de collecte actuel. UpdateUI<private>() : void = if (PlayerUI := MaybePlayerUI?): PickupLevelWidget.SetText(PickupLevelText(PickupLevel)) PendingScoreWidget.SetText(PendingScoreText(PendingScore)) PendingScoreWidget.SetText(TotalGameScoreText(TotalGameScore))
Créez une fonction nommée AddScoreManagerToUI() qui met à jour l'interface utilisateur du joueur avec l'interface utilisateur du gestionnaire de score personnalisé. AddScoreManagerToUI<public>() : void = if (PlayerUI := MaybePlayerUI?): PlayerUI.AddWidget(Canvas) UpdateUI()
Créez une fonction pour chaque valeur qui s'affiche dans l'interface utilisateur afin que la boucle de jeu puisse mettre à jour les valeurs :
- Une fonction nommée AddPendingScoreToTotalScore() avec le spécificateur public. Cette fonction doit ajouter le score en attente au score total du jeu et remettre la valeur du score en attente à 0. Vous pouvez reporter la remise à zéro du score PendingScore et la mise à jour de l'interface utilisateur après la mise à jour du score TotalGameScore. Cela évite d'utiliser une variable temporaire pour contenir la valeur de PendingScore avant sa remise à zéro.
  Verse
```
<# Adds PendingScore to TotalGameScore and resets PendingScore to 0.#> AddPendingScoreToTotalScore<public>() : void = defer: 
set PendingScore = 0 UpdateUI() 
set TotalGameScore += PendingScore
```
  <# Adds PendingScore to TotalGameScore and resets PendingScore to 0.#> AddPendingScoreToTotalScore<public>() : void = defer: set PendingScore = 0 UpdateUI() set TotalGameScore += PendingScore
- Une fonction nommée UpdatePendingScore() avec le spécificateur public et un paramètre entier nommé Points que la fonction ajoutera au score en attente actuel.
  Verse
```
<# Adds the given amount of points to the pending points. #> 
UpdatePendingScore<public>(Points : int) : void =   set PendingScore += Points UpdateUI()
```
  <# Adds the given amount of points to the pending points. #> UpdatePendingScore<public>(Points : int) : void = set PendingScore += Points UpdateUI()
- Une fonction nommée UpdatePickupLevel avec le spécificateur public et un paramètre entier nommé Level, qui est la nouvelle valeur du niveau de collecte actuel.
  Verse
```
UpdatePickupLevel<public>(Level : int) : void = set PickupLevel = Level UpdateUI()
```
  UpdatePickupLevel<public>(Level : int) : void = set PickupLevel = Level UpdateUI()
- Créez une fonction nommée AwardScore() avec le spécificateur public. Cette fonction attribue le score au joueur en utilisant l'appareil Gestionnaire de score et l'active.
  Verse
```
<# Awards the score to the player with the Score Manager device, by activating it. #> AwardScore<public>() : void = ScoreManagerDevice.SetScoreAward(TotalGameScore) if (AwardedPlayer := MaybePlayer?):   
  ScoreManagerDevice.Activate(AwardedPlayer)
```
  <# Awards the score to the player with the Score Manager device, by activating it. #> AwardScore<public>() : void = ScoreManagerDevice.SetScoreAward(TotalGameScore) if (AwardedPlayer := MaybePlayer?): ScoreManagerDevice.Activate(AwardedPlayer)

Votre classe score_manager doit maintenant être similaire à ce qui suit :

Verse

     score_manager := class:
         <# Since we won't recreate the canvas during the score manager lifetime, do it once anytime an object of this type is created.>
         block:
             set Canvas = canvas:
                 Slots := array:
                     canvas_slot:
                         Anchors := anchors{Minimum := vector2{X := 0.0, Y := 0.25}, Maximum := vector2{X := 0.0, Y := 0.25} }
                         Offsets := margin{Top := 0.0, Left := 25.0, Right := 0.0, Bottom := 0.0}
                         Alignment := vector2{X := 0.0, Y := 0.0}
                         SizeToContent := true

Maintenant que vous avez créé votre classe score_manager, créez un constructeur pour que la classe puisse initialiser les variables du joueur depuis le jeu. Notez que vous devez convertir la référence de joueur d'agent à player afin d'obtenir une référence à l'IU du joueur.
Verse
```
     MakeScoreManager<constructor><public>(InPlayer : agent, InScoreManagerDevice : score_manager_device) := score_manager:
         MaybePlayer := option{InPlayer}
         MaybePlayerUI := option{GetPlayerUI[player[InPlayer]]}
```
MakeScoreManager<constructor><public>(InPlayer : agent, InScoreManagerDevice : score_manager_device) := score_manager: MaybePlayer := option{InPlayer} MaybePlayerUI := option{GetPlayerUI[player[InPlayer]]}

Votre fichier score_manager.verse doit maintenant être similaire à ce qui suit :

Verse

     using { /UnrealEngine.com/Temporary/SpatialMath}
     using { /UnrealEngine.com/Temporary/UI }
     using { /Fortnite.com/Devices }
     using { /Fortnite.com/UI }
     using { /Verse.org/Colors }
     using { /Verse.org/Simulation }

     MakeScoreManager<constructor><public>(InPlayer : agent, InScoreManagerDevice : score_manager_device) := score_manager:
         MaybePlayer := option{InPlayer}
         MaybePlayerUI := option{GetPlayerUI[player[InPlayer]]}

Mettre à jour le score et l'interface utilisateur dans la boucle de jeu

Procédez comme suit pour créer et mettre à jour votre interface utilisateur pendant le jeu dans le fichier game_coordinator_device.verse :

Ajoutez les propriétés suivantes à la classe game_coordinator_device :
- Une variable score_manager nommée ScoreManager avec le spécificateur private. Cette instance gère le score et l'interface utilisateur du joueur. var ScoreManager<private> : score_manager = score_manager{}
- Un appareil score_manager_device modifiable que vous pouvez définir comme le gestionnaire de score dans le niveau. Il s'agit de l'appareil que la classe score_manager va utiliser. @editable ScoreManagerDevice<public> : score_manager_device = score_manager_device{}
- Une matrice d'entiers modifiable nommée PointsForPickupLevel avec le spécificateur public, pour définir les points que le joueur peut marquer pour chaque niveau de collecte. @editable # Indique le nombre de points que vaut une collecte en fonction de son niveau. PointsForPickupLevel<public> : []int = array{1, 2, 3}

Dans la fonction StartGame, initialisez la variable du gestionnaire de score en appelant le constructeur MakeScoreManager() avec une référence au joueur et à l'appareil Gestionnaire de score, puis générez l'interface utilisateur afin que le joueur puisse y accéder.

Verse

     StartGame<private>()<suspends> : void =
         Logger.Print("Trying to start the game...")
		
         # We construct a new countdown_timer that'll countdown from InitialCountdownTime once started.
         # Also construct a new score_manager that'll keep track of the player's score and pickup level.
         # The countdown_timer and score_manager require a player to show their UI to.
         # We should have a valid player by now: the one that entered the vehicle, triggering the game start. 
         if (ValidPlayer := MaybePlayer?):
             Logger.Print("Valid player, starting game...")

Dans la fonction PickupDeliveryLoop() de la boucle de jeu, mettez à jour l'interface utilisateur chaque fois que le niveau de collecte change et que le joueur termine une collecte ou une livraison :

Verse

     PickupDeliveryLoop<private>()<suspends> : void =
         PickupZonesTags : []pickup_zone_tag = array{pickup_zone_level_1_tag{}, pickup_zone_level_2_tag{}, pickup_zone_level_3_tag{}}
         MaxPickupLevel := PickupZonesTags.Length - 1
         FirstPickupZoneCompletedEvent := event(){}

         loop:
             var PickupLevel : int = 0
             var IsFirstPickup : logic = true

             # Every time the loop restarts, we should reset the pickup level UI through the ScoreManager.

Maintenant, à la fin du compte à rebours, attribuez au joueur son score. Dans HandleCountdownEnd(), appelez ScoreManager.AwardScore(). HandleCountdownEnd<private>(InPlayer : player)<suspends>:void= TotalTime := CountdownTimer.CountdownEndedEvent.Await() ScoreManager.AwardScore() EndGame.Activate(InPlayer)

Votre fichier game_coordinator_device.verse doit maintenant être similaire à ce qui suit :

Verse

     using { /Verse.org/Simulation }
     using { /Fortnite.com/Devices }
     using { /Fortnite.com/Vehicles }
     using { /Fortnite.com/Characters }
     using { /Fortnite.com/Playspaces }
     using { /Verse.org/Random }
     using { /UnrealEngine.com/Temporary/Diagnostics }
     using { /UnrealEngine.com/Temporary/SpatialMath }
     using { /EpicGames.com/Temporary/Curves }
     using { /Verse.org/Simulation/Tags }

Étape suivante

5. Améliorer le retour et l'expérience du joueur
Créez un jeu avec Verse dans lequel les joueurs doivent collecter et livrer des pizzas avant la fin du compte à rebours.