Real-Time First Time User Experience

As of Skillz SDK version 27 and later, developers can implement tutorial matches for the first-time user experience that include a combination of asynchronous and real-time gameplay. A new player is directed to play these matches before being allowed to explore other parts of the app so that they have a firm enough grasp of the game mechanics to enjoyably play the game.

Skillz has developed optimal paths for new users arriving in the game who do not yet know how to play, such that they are provided with valuable learning experience and grow confident about their abilities to compete.

The Skillz SDK allows this first time user experience to be customized and deployed remotely via changing client parameters.

To implement this a developer must create:

• An asynchronous game mode (if their game is already released on Skillz, this will be what they have currently)
• A real-time game mode
• A real-time bot that the player will be matched against

Once implemented, Skillz can control:

• Whether players are forced to play an async match as their first match, followed by another async match
• Whether the player is forced to play a real-time match (rather than an async match) as their first match, followed by another real-time match -- where you can specify more than real-time matches to be played after the first
• Whether the player is forced to play an async, followed by a real-time match -- where you can specify more than one real-time matches to be played after the first

Note that currently the system only works with one type of match for async and real-time -- so you cannot force the new player to play several different game modes in a row, for example.

How to Implement a First-Time User Experience (FTUE)

If this is the first time thinking about how players will progress through their first encounter with your game we recommend that you read this article which describes how to implement an asynchronous FTUE.

Here is one example of what the system can do using the Skillz game Diamond Strike with the Real-Time FTUE flows. In this flow for Diamond Strike we see that two configurations have been chosen: 2 games for real-time, and 2 games with a Hybrid First Time User Experience (FTUE) including both Async and Real-Time.

• Note that the first step, the Mechanics Tutorial, is a short explanation of the core mechanics of Diamond Strike which is implemented by the developer outside of the FTUE flow governed by the Skillz SDK
  • Many games like to put a short tutorial portion before the Skillz SDK initializes
  • In this tutorial you can either lead players through a subset of the game, or create a tutorial version of a full match -- it varies from game to game
• Some developers choose to skip the mechanics tutorial and go straight to an async match where they explain the rules to players while they play against a real opponent
  • This depends on the type of game, and what works for you and your players!
  • This can be done with real-time as well, but you will need a real-time bot
• Once the Skillz SDK initializes, however, you should follow the guidelines on this page to provide the different async and real-time modes for it to call into

Async FTUE Implementation

Typically this has been something that the developers implement by storing a flag on an install level (in the user preferences in Unity, for example) that govern whether the player gets a First Time User Experience.

• Some did this before the initialization of the Skillz SDK
• Some did this before the first match (better for slides, not as good for a full mechanics tutorial)

Adding a Real-Time (Real-Time) FTUE

note

Real-time bot opponents are only permitted during the First Time User Experience, which consists of the mandatory Z tournaments a player goes through after a new install. The primary goal of the Real-time bot opponents is to educate the players on the game mechanics while also giving them an idea of the in-game experience.

Real-Time FTUE Match Design Goals

• If you use different mechanics for your real-time matches you should use the real-time FTUE match as an opportunity to teach these mechanics to the player
  • Typically this has been accomplished by first showing a short real-time mechanics tutorial
  • Then the player plays one or more bot matches (controlled by the Skillz SDK)
• It should be made explicit to the player that they are playing a bot by displaying the opponent avatar and username in game. The bot avatar and username (TrainerBot) are determined by Skillz.
• If a player forfeits against a bot
  • The player’s score should be changed to whatever the default losing score is for that game (see the guidelines on forfeits)
  • Developer should ensure that the bot submits a score and wins the game
• Disconnecting from a FTUE match
  • Should cause the player to submit an abort (see the guidelines on aborts) -- this should be handled by the Skillz SDK
  • Developer should ensure that the bot submits a score and wins the game
• Note that you cannot use the new split Score Submission methods in the real-time bot match

Real-Time Bots

Due to the nature of real-time gameplay the developers will have to implement a bot for players to play against in a real-time match where you are trying to train them how to play.

Setting Up Your Real-Time FTUE Match

Overview

• The Skillz SDK will be passing a Match object to the On Match Will Begin delegate containing special flags for the real-time FTUE match.
• The Match object has a Customer Server Connection Info with a new flag called Is Bot Match
• So your On Match Will Begin delegate should watch for the Is Bot Match flag in order to launch into the real-time ftue
• At this point the developer should launch either into their own server for the bot match, or to run the bot match locally

Important Note

The Skillz SDK might ask the player to play more than one bot match. So if there is a pre-match tutorial, only show it for the first Real-Time FTUE bot match played!

API for Bot Matches

IsBotMatch is a new field that has been added to the Real-Time Connection Info. This means that bot matches are only supported on games using the Sync v2 architecture.

• iOS This can be determined by the isBotMatch field of the SKZSyncConnectionInfo object that is included in the match info.
• Android This can be determined by the isBotMatch field of the SyncConnectionInfo inside the Skillz Match object.
• Unity This can be determined by the isBotMatch field of the CustomServerConnectionInfo object that is inside the Match received in the OnMatchWillBegin delegate method.

Report Score for Bot Match

When your player has finished their FTUE real-time match, you will need to submit scores to return back to the Skillz SDK. We have added new methods to submit scores for bot matches.

Unity/C#

/// <summary>
    /// Call this method when a player's score is finalized to report their score to the Skillz server.
    /// This methods does not return control to the Skillz SDK.
    /// </summary>
    ///
    /// <param name="score">The player's score as an integer.</param>
    /// <param name="successCallback">A callback function that is invoked when the score submit completes successfully</param>
    /// <param name="failureCallback">A callback function that is invoked when the score submit fails. It is invoked with an error message parameter.</param>
    public static void SubmitScore(int score, Action successCallback, Action<string> failureCallback)

iOS/Swift

/**
 * Call this function to report the player's score to Skillz if the current match is a synchronous match against a training bot. Ends the
 * current tournament, and returns the user to the Skillz experience.
 *
 * @param playerScore            Numeric value representing the player's final score
 * @param botScore            Numeric value representing the bot's final score
 * @param completion            Completion will be called on wrap up so that the developer can finish any ongoing processes, such as
 *                         saving game data or removing the game from the view hierarchy.
 *
 * Note: If your game is resource intensive, you should attempt to release as much memory as possible prior to calling this method.
 */
- (void)displayResultsForBotMatchWithPlayerScore:(NSNumber * _Nonnull)playerScore
                                        botScore:(NSNumber * _Nonnull)botScore
                                      completion:(void (^_Nonnull)(void))completion;

iOS/Objective-C

 /**
     * Validate match id then reports scores for the player and their bot opponent to Skillz
     * from a given activity in the synchronous gameplay on-boarding experience.
     *
     * @param activity The activity to report the score from.
     * @param playerScore The score to report for the current player.
     * @param botScore The score to report for the bot.
     * @param matchId  The id of the current match.
     */
    public static void reportScoreForBotMatch(@NonNull final Activity activity, BigDecimal playerScore, BigDecimal botScore, String matchId)

---

Set Game Has Bot Match

Developers will need to indicate that a given build has support for a bot match. If they do not, we will NOT send them through the Sync FTUE and they will instead always see the Async FTUE.

Unity/C#

A checkbox for the Unity Wrapper was added to the Skillz Settings. A developer must simply check this box, and the Unity Skillz Wrapper will handle exporting the flags properly for each native platform. This box is unchecked by default.

iOS/Swift

/**
 * If your game has a synchronous gameplay training bot, call this method immediately after calling
 * initWithGameId:forDelegate:withEnvironment:allowExit: with the value YES to inform Skillz that your build has a training bot implemented.
 *
 * Only call this if your game has synchronous gameplay with a custom server and you have implemented a sync training
 * bot to be used in onboarding the player to the Skillz Experience.
 *
 * @param hasSyncBot whether or not your game has implemented a synchronous training bot
 */
- (void)setGameHasSyncBot:(BOOL)hasSyncBot;

iOS/Objective-C

<meta-data android:name="skillz_game_has_sync_bot" android:value="true" />

Real-Time Tutorial Best Practices

If a game features a real-time mode, the tutorial - regardless of the configuration - should include a section at the end explaining that it is possible to play a real-time match with a human opponent. This information should appear in both the async tutorial and the real-time tutorial. In fact, unless there is an explicit need to call out real-time only functionality, we recommend only implementing the initial mechanics tutorial before the first async match. If it is determined that the real-time mode absolutely must include different information than the async mode, match info can be used to dynamically determine which tutorial to show.

Data shows that players that experience real-time play early on are much more likely to engage with pro tournaments. Any opportunity to remind players that real-time play is supported will positively impact a game’s metrics.

For real-time games, we also recommend notifying the player that they can play real-time games against a human opponent as soon as they complete their last match of the FTUE flows. Currently, the best time to relay this information is immediately upon completion of that second practice match and before the results screen (where the player presses Submit Score), as once the results screen appears, the player must be transitioned directly back to the SDK.