5. Refactor and Refine

This final tutorial step shows you how to improve your code while teaching some important Verse concepts as you go.

Improve Your Verse Code

Refactoring is a process in which you restructure existing code to improve the design or implementation without changing its behavior. The following are the most common goals when refactoring your code:

• Improving readability with better variable naming, better spacing or overall code structure.

• Improving performance with simpler or more efficient implementation of behavior.

• Reducing repetition and code bloat (large, unnecessary or overly complex code) by condensing similar functions into one or gathering multiple variables of similar type and purpose into containers like arrays.

Refactoring by following these goals should help you write code that is maintainable, easy to read and revisit, and extensible, easy to extend the capabilities of for future enhancements to the behavior. Making your games really level up!

GetFirstPlayer()

Writing readable code is a great programming practice. For example, GetFirstPlayer() is clearer than GetPlayspace().GetPlayers()[0]. Additionally, this approach is a best practice for programming common operations as it clearly states the operation's intent.

1. Open the shooting_range_manager_device.verse file.

2. Add the GetFirstPlayer method.

   Notice the GetFirstPlayer method has the <decides><transacts> effect specifiers because it can fail and rollback. Read Failure in Verse for more details about failable expressions and failure contexts.    

   Verse

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

   Copy full snippet(3 lines long)

3. Modify the AdjustScore method to use the new GetFirstPlayer method. 

   Notice that the GetFirstPlayer method is called with brackets instead of parentheses because it is failable.

   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. Modify the IncreaseWeaponLevel method to use the new GetFirstPlayer method.

   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)

Target Class Wrappers and Arrays

Another key goal when cleaning up code is minimizing duplication. In the current implementation, each Good and Bad Target defines its own callback and hit flag, making the code repetitive.

A better approach is to create a wrapper class that contains everything an individual target needs. The shooting range manager can then manage these target wrappers in an array, rather than defining each component individually.

This not only reduces duplication but also improves scalability. You can add as many targets as you like without writing additional code.

1. Define the good_target_wrapper class. You can put this above your shooting_range_manager_device class definition.

   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. Define the bad_target_wrapper class. You can put this above your shooting_range_manager_device class definition.

   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. Add the following array properties to your shooting range manager device.

   Verse

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

   Copy full snippet(5 lines long)

4. Remove the following from your shooting range manager device. These are handled by the wrapper classes now.

   • GoodTarget1-3

   • GoodTargetScore

   • BadTarget1-3

   • BadTargetScore

   • HitGoodTarget1-3

   • OnGoodTarget1-3Hit()

   • OnBadTarget1-3Hit()

5. Modify the OnBegin method to initialize the Good and Bad Targets by looping through the array.

   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. Modify the CheckCombo method to check for combo completion by looping through the Good Target array.

   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. Update the ResetCombo method to loop through the Good Target array.

   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. Save and build your Verse code.

Complete Code

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:

Bring It Together

You must set new values for the changed editable properties on your Verse device.

1. Select the shooting_range_manager_device in the viewport or Outliner panel.

2. In the Details panel, set the following parameters:

   1. Add three elements to the GoodTargets array and set each to their respective targets. Optionally, you can also change the score value of an individual target now.

   2. Add three elements to the BadTargets array and set each to their respective targets. You can also optionally change the score value of an individual target now.

   3. Verify all other properties are set as expected.

On Your Own

This section is over, but you don't have to be. For more Verse functionality and gameplay, see the documentation in Learn Game Mechanics.