Real-Time First Time User Experience (FTUE)
A new player is directed to play practice matches in a first time user experience (FTUE) before being allowed to explore other parts of the app. It is recommended to implement a Game Mechanics Tutorial and Practice Trainer matches for the FTUE. This will ensure the player has a grasp of the gameplay before they compete in a competitive match, or a match for a prize. In all instances where you use the Practice Trainer in the FTUE, the player should be alerted to the fact that he or she is playing against a Practice Trainer. Additionally, the player will not be allowed to compete for prizes during these practice matches.
Game Mechanics Tutorial
A Game Mechanics Tutorial is a short explanation of the core mechanics of the game, which is implemented by the developer outside of the FTUE flow governed by the Skillz SDK. Many games like to add a short game tutorial 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.
Implementing a Game Mechanics Tutorial
If you have not implemented a Game Mechanics Tutorial, see here for a best practices guide.
FTUE in Real-Time Games
If a Practice Trainer is not implemented in your game, then a player will land on the play screen after creating their profile and there is no FTUE.
If a Practice Trainer is implemented in your game, then a player will go through two real-time tournaments during the FTUE.
FTUE in Combined Real-Time and Play-and-Compare Games
If a Practice Trainer is not implemented in your game, then the FTUE will consist of a player going through two Play-and-Compare matches.
If a Practice Trainer is implemented in your game, then the FTUE will consist of a player going through one Play-and-Compare match and one Real-Time match.
Implementing a Practice Trainer for FTUE
Overview
- Indicate that a given build has support for a Practice Trainer match in the Skillz settings.
- 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 calledIsBotMatch
. - Your
OnMatchWillBegin
callback should watch for theIsBotMatch
flag in order to trigger the Practice Trainer match, either into their own server for the Practice Trainer match, or to run the Practice Trainer match locally.
Skillz Settings
You will need to indicate that a given build has support for a Practice Trainer match. If you do not, we will NOT send the player through the real-time FTUE.
A checkbox labeled Has Synchronous Bot
can be checked under Skillz Settings. Simply check this box, and the Unity Skillz Wrapper will handle exporting the flags properly for each platform. This box is unchecked by default.
API for Practice Trainer Matches
- Unity/C#
- iOS
- Android
public void OnMatchWillBegin(SkillzSDK.Match match)
{
if ( match.CustomServerConnectionInfo.IsBotMatch )
{
// custom code to launch bot match
}
}
The match object can also be retrieved from the SkillzCrossPlatform API:
if ( SkillzCrossPlatform.GetMatchInfo().CustomServerConnectionInfo.IsBotMatch )
{
// custom code for bot match
}
This can be determined by the isBotMatch field of the SKZSyncConnectionInfo object that is included in the match info.
This can be determined by the isBotMatch field of the SyncConnectionInfo inside the Skillz Match object.
Reporting Score for Practice Trainer Matches
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 Practice Trainer matches.
- Unity/C#
- iOS
- Android
/// <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)
/**
* Call this function to report the player's score to Skillz if the current match is a real-time 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;
/**
* Validate match id then reports scores for the player and their bot opponent to Skillz
* from a given activity in the real-time 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)
Creating a Practice Trainer Match
This step will be unique to each game. The specific implementation will depend on the type of game and specific gameplay requirements. Generally, an opponent's actions will need to be simulated in some way and displayed to the user as if the opponent was a real player. These matches are tutorial in nature and do not involve entry fees or prizes.
FTUE Controls in Developer Console
You can manage the FTUE for real-time games to change:
- Wait times before a player is matched with a Practice Trainer.
- Number of tournaments to complete the FTUE.
- Type of FTUE match (Play-and-Compare, Real-Time, Hybrid).
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 play-and-compare 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 match. If it is determined that the real-time mode absolutely must include different information than the play-and-compare 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 using a FTUE flow, 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.