5. Refactoriser et affiner

Dans cette dernière étape du tutoriel, nous vous montrons comment améliorer votre code tout en vous expliquant certains concepts importants de Verse.

Améliorer votre code Verse

La refactorisation est un processus consistant à restructurer le code existant afin d'améliorer sa conception ou son implémentation sans modifier son comportement. Voici les objectifs de refactorisation de code les plus courants :

• améliorer la lisibilité grâce à une meilleure dénomination des variables, un meilleur espacement ou une meilleure structure globale du code ;

• améliorer les performances grâce à une implémentation de comportement plus simple ou plus efficace ;

• réduire les répétitions et le code superflu (code volumineux, inutile ou trop complexe) en condensant les fonctions similaires en une seule ou en regroupant plusieurs variables de type et d'utilité identiques dans des conteneurs tels que des matrices.

Refactoriser en gardant ces objectifs à l'esprit vous permet de rédiger un code facile à gérer, à lire et à réviser, mais aussi extensible et facile à étendre pour de futures améliorations de comportement. Faites passer vos jeux au niveau supérieur

GetFirstPlayer()

Rédiger du code lisible est une bonne habitude à prendre. Par exemple, il est plus clair d'écrire GetFirstPlayer() que GetPlayspace().GetPlayers()[0]. Vous pouvez donc adopter cette approche pour programmer des opérations courantes de façon à indiquer clairement l'intention de chaque opération.

1. Ouvrez le fichier shooting_range_manager_device.verse.

2. Ajoutez la méthode GetFirstPlayer.

   Notez que la méthode GetFirstPlayer dispose des spécificateurs d'effet <decides><transacts>, car elle est susceptible d'échouer et d'être annulée. Consultez la page Échec dans Verse pour en savoir plus sur les expressions faillibles et les contextes d'échec.    

   Verse

       # Returns the first player in the playspace.
       GetFirstPlayer()<decides><transacts>:player=
           return GetPlayspace().GetPlayers()[0]
   

   Copy full snippet(3 lines long)

3. Modifiez la méthode AdjustScore pour utiliser la nouvelle méthode GetFirstPlayer. 

   Notez que la méthode GetFirstPlayer est appelée avec des crochets et non avec des parenthèses, car elle est faillible.

   Verse

       # Adjusts the player's score by the provided value.
       AdjustScore(Value:int):void=
           # Start the timer if it hasn't started yet.
           if (not IsTimerStarted?):
               StartTimer()
          
           # Sets the score award to the base value of the target multiplied by the current weapon level.
           ScoreManager.SetScoreAward(Value * CurrentWeaponLevel)
   
   <# --- New Code Start --- #>
   
   Expand code Copy full snippet(37 lines long)

4. Modifiez la méthode IncreaseWeaponLevel pour utiliser la nouvelle méthode GetFirstPlayer.

   Verse

       # Increases the player's weapon level by one (up to the maximum value).
       IncreaseWeaponLevel():void=
           if:
               # If able to retrieve the first player and current weapon level isn't maxed, then...
   
   <# --- New Code Start --- #>
   
               Player:player = GetFirstPlayer[]
   
   <# --- New Code End --- #>
   
   Expand code Copy full snippet(16 lines long)

Wrappers et matrices de classe cible

Un autre objectif clé du nettoyage de code est de minimiser les doublons. Dans l'implémentation actuelle, chaque bonne cible et chaque mauvaise cible définissent leur propre rappel et leur propre indicateur de réussite, ce qui rend le code répétitif.

Une bonne démarche consiste à créer une classe de wrapper qui contient tout ce dont une cible a besoin. Le gestionnaire du stand de tir peut alors gérer ces wrappers de cible dans une matrice, plutôt que de définir chaque composant séparément.

Cela permet non seulement de réduire les doublons, mais aussi d'améliorer l'évolutivité. Vous pouvez ajouter autant de cibles que vous le souhaitez, sans avoir à écrire de code supplémentaire.

1. Définissez la classe good_target_wrapper. Vous pouvez la placer au-dessus de votre définition de classe shooting_range_manager_device.

   Verse

   # A wrapper class for the good targets to support array storage with a self-contained event callback.
   good_target_wrapper := class:
   
       @editable
       Target:shooting_range_target_track_device = shooting_range_target_track_device{}
   
       @editable
       Score:int = 100
   
       # A circular reference to the shooting range manager device.
   
   Expand code Copy full snippet(32 lines long)

2. Définissez la classe bad_target_wrapper. Vous pouvez la placer au-dessus de votre définition de classe shooting_range_manager_device.

   Verse

   # A wrapper class for the bad targets to support array storage with a self-contained event callback.
   bad_target_wrapper := class:
   
       @editable
       Target:shooting_range_target_device = shooting_range_target_device{}
   
       @editable
       Score:int = -100
   
       # A circular reference to the shooting range manager device.
   
   Expand code Copy full snippet(22 lines long)

3. Ajoutez les propriétés de matrice suivantes à votre gestionnaire de stand de tir.

   Verse

       @editable:
       GoodTargets:[]good_target_wrapper = array{}
   
       @editable
       BadTargets:[]bad_target_wrapper = array{}
   

   Copy full snippet(5 lines long)

4. Supprimez les éléments suivants de votre gestionnaire de stand de tir. Ceux-ci sont désormais gérés par les classes de wrappers.

   • GoodTarget1-3

   • GoodTargetScore

   • BadTarget1-3

   • BadTargetScore

   • HitGoodTarget1-3

   • OnGoodTarget1-3Hit()

   • OnBadTarget1-3Hit()

5. Modifiez la méthode OnBegin de façon à initialiser les bonnes et mauvaises cibles en parcourant en boucle la matrice.

   Verse

       # Runs when the device is started in a running game.
       OnBegin<override>()<suspends>:void=
   
   <# --- New Code Start --- #>
   
           # Initialize GoodTargets.
           for (GoodTarget : GoodTargets):
               GoodTarget.Init(Self)
   
           # Initialize BadTargets.
   
   Expand code Copy full snippet(26 lines long)

6. Modifiez la méthode CheckCombo de façon à vérifier la réalisation du combo en parcourant en boucle la matrice de bonnes cibles.

   Verse

       # If the combo is complete, enable the ComboTarget.
       CheckCombo():void=
   
   <# --- New Code Start --- #>
   
           # If any of the good targets are not hit, exit the function.
           for (GoodTarget : GoodTargets):
               if (not GoodTarget.IsHit?):
                   return
   
   
   Expand code Copy full snippet(14 lines long)

7. Mettez à jour la méthode ResetCombo pour parcourir en boucle la matrice de bonnes cibles.

   Verse

       # Resets the combo tracking variables, re-enables all GoodTargets, and disables the ComboTarget.
       ResetCombo():void=
   
   <# --- New Code Start --- #>
   
           for (GoodTarget : GoodTargets):
               GoodTarget.Reset()
   
   <# --- New Code End --- #>
   
   
   Expand code Copy full snippet(12 lines long)

8. Enregistrez et générez votre code Verse.

Code complet

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

<#>
    Utility Classes
<#>

# A wrapper class for the good targets to support array storage with a self-contained event callback.
good_target_wrapper := class:

Assembler tous les éléments

Vous devez définir de nouvelles valeurs pour les propriétés modifiables sur votre appareil Verse.

1. Sélectionnez shooting_range_manager_device dans le hublot ou dans le panneau Organiseur.

2. Dans le panneau Détails, définissez les paramètres suivants :

   1. Ajoutez trois éléments à la matrice GoodTargets et définissez chacun d'eux sur leurs cibles respectives. Vous pouvez éventuellement modifier la valeur de score d'une des cibles.

   2. Ajoutez trois éléments à la matrice BadTargets et définissez chacun d'eux sur leurs cibles respectives. Vous pouvez éventuellement modifier la valeur de score d'une des cibles.

   3. Assurez-vous que toutes les autres propriétés sont définies comme prévu.

À vous de jouer

Cette section est terminée, mais vous pouvez poursuivre votre parcours d'apprentissage si vous le souhaitez. Pour en savoir plus sur les fonctionnalités et le gameplay dans Verse, consultez la documentation Apprendre les mécaniques de jeu.