Triumph Lifecycle

Integrate Triumph scoring in your game. Estimated Time: 10 minutes.

Start Game

Triumph needs to start an instance of your game when a match is initiated. We will call a function TriumphGameDidStart when we would like a game to start. You will implement this function with logic to start an instance of your game.

Unity

Implement the TriumphUnityNativeMethods component of the TriumphAPI prefab.

using UnityEngine;
using TriumphSDK;

public class TriumphUnityNativeMethods: MonoBehaviour, ITriumphUnityNativeMethods {
    
    /*
    * TODO: implement this method, which we will call when. 
    * a user has initiated a tournament.
    */
    public void TriumphStartedGame() 
    {
        StartYourGame();
    }
    
    // MARK: -- Optional 
    
    /*
     * If you provided `hasTutorial` flag within configuration options,
     * this method will be called when Triumph wants to show the tutorial.
     * You can start a fullscreen video with your gameplay mechanics
     * or launch a playable game with hints to onboard new players.
     */
    public void TriumphRequestsTutorial() 
    {
        StartYourTutorial();
    }
    
    /*
     * The below methods can be used for logging purposes, 
     * left blank, or whatever you'd like. 
     * Please leave them in the code (even if blank). 
    */
    
    // We call this when the triumph SDK is dismissed.
    public void TriumphDidDismiss() 
    {
    }
    
    // Called when the SDK presents
    public void TriumphDidPresent() 
    {
    }
    
    // Called right before the SDK dismisses
    public void TriumphWillDismiss() 
    {
    }
    
    // Called right before the SDK presents
    public void TriumphWillPresent() 
    {
    }
}

When you finished presenting tutorial to a new player, do not forget to present Triumph again:

using TriumphSDK;

public class TutorialScene : MonoBehaviour {

    // Called when your tutorial has finished playing
    public void TutorialFinished() {
        Triumph.present()
    }
}

Swift

Navigate to the file where your gameplay lifecycle is managed, i.e. where you have the ability to start and end games.

Set Triumph.delegate = self in the viewDidLoad function of this class, and conform to TriumphDelegate. This allows us to pass data between your game and Triumph.

import TriumphSDK

class YourGameViewController: TriumphDelegate {
    
    // Allows Triumph to communicate with your game 
    func viewDidLoad() {
        Triumph.delegate = self
    }
    
    // Required: reset and start your game here. 
    func triumphStartedGame() {
        startYourGame()
    }
    
    // MARK: -- Optional 
    
    /*
     * If you provided `hasTutorial` flag within configuration options,
     * this method will be called when Triumph wants to show the tutorial.
     * You can start a fullscreen video with your gameplay mechanics
     * or launch a playable game with hints to onboard new players.
     */
    func triumphRequestsTutorial() {
        startYourTutorial()
    }
    
    /*
     * The below methods can be used for logging purposes, 
     * left blank, or whatever you'd like. 
     * Please leave them in the code (even if blank). 
     */
    
    // Tells you that Triumph will present
    func triumphWillPresent() {}
    
    // Tells you that Triumph did present
    func triumphDidPresent() {}
    
    // Tells you that Triumph will dismiss
    func triumphWillDismiss() {}
    
    // Tells you that Triumph was dismiss
    func triumphDidDismiss() {}
}

When you finished presenting tutorial to a new player, do not forget to present Triumph again:

class YourTutorialViewController {

    // Called when your tutorial has finished playing
    func tutorialFinished() {
        Triumph.present()
    }
}

These method implementations will be called on our end when appropriate. Do not call these methods anywhere yourself.

Game pause/resume

(Optional) If you have pausing functionality in your game, please add the following Triumph functions. This allows us to optimize replay recordings of your game.

Unity

using TriumphSDK;

public class GameScene : MonoBehaviour {
    
    // Your pause game business logic
    void Pause()
    {
        // Add this Triumph function
        Triumph.GamePaused();
    }
    
    // Your resume game business logic
    void Resume()
    {
        // Add this Triumph function
        Triumph.GameResumed();
    }
}

Swift

import TriumphSDK

class YourGameViewController {
    // Your pause game business logic
    func pause() {
        // Add this Triumph function
        Triumph.gamePaused()
    }
    
    // Your resume game business logic
    func resume() {
        // Add this Triumph function
        Triumph.gameResume()
    }
}

Report Score

Triumph needs to record scores from your game. There are two functions that you will call:

• updateScore should be called whenever the score of your game changes, passing the current score as a parameter. This allows us to keep intermediate scores stored in the state of our SDK, so if a game crashes before completion, we have something for the user's score rather than simply reporting 0.

• gameOver should be called when a game ends, passing the final score of the game as a parameter. This will submit the final score and resummon Triumph's UI.

Unity

using TriumphSDK;

public class GameScene : MonoBehaviour {
    public int score = 0;
    
    // Whenever a score changes, call updateScore with the current score.
    // @Params: score: double
    public void IncreaseScore(int increment) 
    {
        score += increment;
        Triumph.UpdateScore(score: score);
    }
    
    // Your game logic when the user loses and the game ends
    // @Params: score: double
    public void EndGame(int finalScore) 
    {
        Triumph.GameOver(score: finalScore);
    }
}

Swift

import TriumphSDK

class YourGameViewController {
    // Whenever a score changes, call updateScore with the current score.
    // Doing this on a didSet ensures we call this on every score update, 
    // although your implementation may differ
    // @Params: score: Double
    var gameScore: Double? {
        didSet {
            Triumph.updateScore(score: gameScore)
        }
    }
    
    // User got a headshot! (or whatever your game logic is)
    func headShot() {
        let HEADSHOT_SCORE_VALUE = 10.0
        
        // Changing the score will trigger the didSet
        // that updates the labels and calls the updateScore 
        // function
        gameScore = gameScore + HEADSHOT_SCORE_VALUE
    }
    
    // Your game logic when a game ends
    func onGameOver() {
        // When the game ends, call this function with the user's final
        // score to resummon Triumph. 
        // @Params: score: Double
        Triumph.gameOver(score: gameScore)
    }
}

Score Labels

Triumph requires your to have two in-game score labels: a large, primary label, and a small, secondary label. These labels will display different things based on the game mode the user is playing. For example, in a 1v1 tournament, the primary label will display the user's score, and the secondary label will display the user's tournament name. In a blitz tournament, the primary label will display the user's winnings in dollars, and the secondary label will display the user's score.

We will give you two methods that you use to get the string values for the primary and secondary label. Every time the score of your game changes, you should also update these labels.

Unity

using TriumphSDK;

public class GameScene : MonoBehaviour { 
    public TMP_Text LargeLabel; 
    public TMP_Text SmallLabel;

    public int Score = 0;

    public void IncreaseScore(int Increment) 
    {
        score += increment;
        Triumph.UpdateScore(score);
        LargeLabel.text = Triumph.GetPrimaryLabel();
        Smalllabel.text = Triumph.GetSecondaryLabel();
    }
}

Swift

import TriumphSDK

class YourGameViewController {
    let largeLabel: UILabel = UILabel()
    let smalLabel: UILabel = UILabel() 
    
    var gameScore: Double? {
        didSet {
            // Whenever a score changes, we call updateScore with the new total score.
            // Doing this on a didSet ensures we call this on every score update, 
            // although your implementation may differ
            // @Params: score: Double
            Triumph.updateScore(gameScore)
            
            // Now that Triumph has an updated score for your game, we get the 
            // primary and secondary labels to display 
            largeLabel.text = Triumph.primaryLabel
            smallLabel.text = Triumph.secondaryLabel
        }
    }
    
    // User got a headshot! 
    func headShot() {
        let HEADSHOT_SCORE_VALUE = 10.0
        
        // Changing the score will trigger the didSet
        // that updates the labels and calls the updateScore 
        // function
        gameScore = gameScore + HEADSHOT_SCORE_VALUE
    }
    
    // Your game logic when the user loses and the game ends
    func onGameOver() {
        // When the game ends, call this function with the user's final
        // score to resummon Triumph. 
        // @Params: with: Double
        Triumph.gameOver(with: gameScore)
    }
}

Location Premissions