Build a live leaderboard and chat in Unity with PubNub

public const string PUBNUB_PUBLISH_KEY                  = "PUBLISH_KEY_HERE";
public const string PUBNUB_SUBSCRIBE_KEY                = "SUBSCRIBE_KEY_HERE";

public static class PubNubConnection
{
    //Persist the PubNub object across scenes
    private static string _userID;
    public static Pubnub pubnub;

    public static string PublishKey
    {
        get { return GameConstants.PUBNUB_PUBLISH_KEY; }
    }

    public static string SubscribeKey
    {
        get { return GameConstants.PUBNUB_SUBSCRIBE_KEY; }
    }

    public static string UserID
    {
        get { return _userID; }
        set { _userID = value; }
    }
}

void InitializePubNub()
{
    // Use this for initialization
    if (pubnub == null)
    {
        PubNubConnection.UserID = SystemInfo.deviceUniqueIdentifier;
        PNConfiguration pnConfiguration = new PNConfiguration(new UserId(PubNubConnection.UserID));
        pnConfiguration.PublishKey = PubNubConnection.PublishKey;
        pnConfiguration.SubscribeKey = PubNubConnection.SubscribeKey;
        pnConfiguration.LogLevel = PubnubLogLevel.Debug;
        pnConfiguration.EnableHttp2 = false; //HTTP/2 transport requires Unity 6.5+.
        PubNubConnection.pubnub = PubnubUnityUtils.NewUnityPubnub(pnConfiguration, webGLBuildMode: Application.platform == RuntimePlatform.WebGLPlayer, unityLogging: true);
        pubnub = PubNubConnection.pubnub;

        StartCoroutine(new PubNubAccessManager().RequestToken(PubNubConnection.UserID, (token) =>
        {
            if (token != null)
            {
                pubnub.SetAuthToken(token);
            }
        }));
    }
}

public IEnumerator RequestToken(string UserId, Action<string> callback)
{
    string TOKEN_SERVER = "https://devrel-demos-access-manager.netlify.app/.netlify/functions/api/unitykartracer";

    public void ToggleStartButton()
    {
        //Cap username at Length of 6.
        if(string.IsNullOrWhiteSpace(usernameInput.text) || usernameInput.text.Length > 6 )
        { 
            startButton.interactable = false;
        }

        else
        {
            startButton.interactable = true;

            //Check for potential profanity. Replace profanity with "*".
            usernameInput.text = ProfanityFilter.ReplaceProfanity(usernameInput.text);
            Player.Username = usernameInput.text;
#if UNITY_WEBGL
            CompleteAction("Enter your username");
#endif
        }
    }

public static class Player
{
    public static double Score { get; set; }
    public static string Username { get; set; }
}

Player.Score = Math.Round(m_TimeManager.TotalTime - m_TimeManager.TimeRemaining,2);

//TimeManager.OnAdjustTime(TimeGained); //Ignoring due to increasing time when collecting rings.

PubNubConnection.UserID = SystemInfo.deviceUniqueIdentifier;
PNConfiguration pnConfiguration = new PNConfiguration(new UserId(PubNubConnection.UserID));
pnConfiguration.PublishKey = PubNubConnection.PublishKey;
pnConfiguration.SubscribeKey = PubNubConnection.SubscribeKey;
pnConfiguration.LogLevel = PubnubLogLevel.Debug;
pnConfiguration.EnableHttp2 = false; //HTTP/2 transport requires Unity 6.5+.
PubNubConnection.pubnub = PubnubUnityUtils.NewUnityPubnub(pnConfiguration, webGLBuildMode: Application.platform == RuntimePlatform.WebGLPlayer, unityLogging: true);
pubnub = PubNubConnection.pubnub;

StartCoroutine(new PubNubAccessManager().RequestToken(PubNubConnection.UserID, (token) =>
{
    if (token != null)
    {
        pubnub.SetAuthToken(token);
    }
    AccessManagerComplete();
}));

MyClass fireRefreshObject = new MyClass();
fireRefreshObject.refresh = "new user refresh";
string firerefreshobject = JsonUtility.ToJson(fireRefreshObject);

// This will trigger the leaderboard to refresh so it will display for a new user. 
pubnub.Fire() 
    .Channel("submit_score")
    .Message(firerefreshobject)
    .Execute((result, status) => {
        if (status.Error)
        {
            Debug.Log(status.Error);
            Debug.Log(status.ErrorData.Information);
        }
        else
        {
            Debug.Log(string.Format("Fire Timetoken: {0}", result.Timetoken));
        }
    });

listener.onMessage += (pn, messageResult) => {
    {
        //Creating arrays from the JSON object containing the payload in order to parse data easier.
        JObject msg = messageResult.Message as JObject;
        if (msg == null)
        {
            return;
        }
        string[] strArr = msg["username"].Select(item => (string)item).ToArray();
        string[] strScores = msg["score"].Select(item => (string)item).ToArray();

        //float templateHeight = 20f;
        for (int i = 0; i < strArr.Length; i++)
        {                
            int rank = i + 1;

            //Obtain the LeaderBoardEntry Row for that rank.
            string entryText = "LeaderboardEntry" + rank;          
            leaderboardEntry = leaderboardContainer.Find(entryText);

            //Rank
            leaderboardEntry.Find("EntryRankText").GetComponent<TMPro.TextMeshProUGUI>().text = rank.ToString();

            //Name            
            leaderboardEntry.Find("EntryUsernameText").GetComponent<TMPro.TextMeshProUGUI>().text = strArr[i];

            //Time (in seconds)        
            leaderboardEntry.Find("EntryTimeText").GetComponent<TMPro.TextMeshProUGUI>().text = strScores[i] + "s";
        }               
    }
};

pubnub.AddListener(listener);

//Subscribes to the specified channel on the PubNub network to receive information.
pubnub.Subscribe<object>()
    .Channels(new string[] {
        "leaderboard_scores"
    })
    .WithPresence()
    .Execute();

private void OnDestroy()
{
    if (pubnub != null)
    {
        pubnub.RemoveListener(listener);
        pubnub.UnsubscribeAll<object>();
    }
}

    public void SubmitTime()
    {
        MyClass mc = new MyClass();
        mc.username = Player.Username;
        mc.score = Player.Score.ToString();
        string json = JsonUtility.ToJson(mc);

        pubnub.Publish()
            .Channel("submit_score")
            .Message(json)
            .Execute((result, status) => {
                if (!status.Error)
                {
                    Debug.Log(string.Format("Publish Timetoken: {0}", result.Timetoken));
                }
                else
                {
                    Debug.Log(status.Error);
                    Debug.Log(status.ErrorData.Information);
                }
            });
        submitTime.interactable = false; // Only allow submit time once.
#if UNITY_WEBGL
        CompleteAction("Submit your time");
#endif
    }

// Fetch the maxMessagesToDisplay messages sent on the given PubNub channel
pubnub.FetchHistory()
    .Channels(new List<string> { channel })
    .MaximumPerChannel(maxMessagesToDisplay)
    .Execute((result, status) =>
    {
        if (status.Error)
        {
            Debug.Log(string.Format(
                " FetchMessages Error: {0} {1} {2}",
                status.StatusCode, status.ErrorData, status.Category
            ));
        }
        else if (result.Messages != null) //Messages is null when the channel has no stored messages.
        {
            foreach (KeyValuePair<string, List<PNHistoryItemResult>> kvp in result.Messages)
            {
                foreach (PNHistoryItemResult pnMessageResult in kvp.Value)
                {
                    // Format data into readable format
                    JSONInformation chatmessage = JsonUtility.FromJson<JSONInformation>(pnMessageResult.Entry.ToString());

                    // Call the function to display the message in plain text
                    CreateChat(chatmessage);
                }
            }
        }
    });

listener.onMessage += (pn, messageResult) => {
    // Format data into a readable format
    JSONInformation chatmessage = JsonUtility.FromJson<JSONInformation>(messageResult.Message.ToString());

    // Call the function to display the message in plain text
    CreateChat(chatmessage);
};
listener.onPresence += (pn, presenceEventResult) => {
    Debug.Log("In Example, SubscribeCallback in presence" + presenceEventResult.Channel + presenceEventResult.Occupancy + presenceEventResult.Event);
};
pubnub.AddListener(listener);
pubnub.Subscribe<object>()
    .Channels(new string[] {
        channel
    })
    .WithPresence()
    .Execute();

void CreateChat(JSONInformation payLoad)
    {
        //Create new chat entry in the lobby chat.
        Transform duplciateContainer = Instantiate(chatContainer, chatScrollContent);
        RectTransform dupRectTransform = duplciateContainer.GetComponent<RectTransform>();
        RectTransform chatInputRect = chatInput.transform.GetComponent<RectTransform>();
        duplciateContainer.gameObject.SetActive(true);
        duplciateContainer.Find("EntryChat").GetComponent<TextMeshProUGUI>().text = $"{payLoad.username}: {payLoad.text}";

        string url = $"{profileGenerator}{payLoad.username}.png?apikey={GameConstants.AVATAR_API_KEY}";

        //Obtain and set the avatar profile picture for that entry.
        StartCoroutine(GetProfileImage(url, duplciateContainer));     
    }

public void SendChat()
{
    // When the user clicks the Submit button,
    // create a JSON object from input field input
    JSONInformation publishMessage = new JSONInformation();
    publishMessage.username = Player.Username;

    //Check for potential profanity. Replace profanity with "*".
    string checkProfanity = ProfanityFilter.ReplaceProfanity(chatInput.text);

    publishMessage.text = checkProfanity;

    string publishMessageToJSON = JsonUtility.ToJson(publishMessage);

    // Publish the JSON object to the assigned PubNub Channel
    pubnub.Publish()
        .Channel(channel)
        .Message(publishMessageToJSON)
        .Execute((result, status) =>
        {
            if (status.Error)
            {
                Debug.Log(status.Error);
                Debug.Log(status.ErrorData.Information);
            }
            else
            {
                Debug.Log(string.Format("Publish Timetoken: {0}", result.Timetoken));
            }
        });

export default (request) => {
    const db = require("kvstore");
    const pubnub = require("pubnub");
    var json = JSON.parse(request.message);
    console.log(json);
    let { username, score } = json;
    var scorearrayprevious = [];
    var scorearraynew = [];
    var usernamearraynew = [];
    var usernamearrayprevious = [];

    //db.removeItem("data"); //reset the block
    db.get("data").then((value) => {
        if(value){
            console.log("value", value);
            let i = 0;
            value.score.some(item => {
                console.log("hello", item, score);
                if(parseFloat(item) > parseFloat(score) || (parseFloat(item) == 0 && score.length > 0)){ //Parse into float since variables are currently strings
                    //Score
                    scorearraynew = value.score.slice(0, i);
                    scorearrayprevious = value.score.slice(i, value.score.length);
                    console.log("values", scorearraynew, scorearrayprevious);
                    scorearraynew.push(score);
                    var newScoreList = scorearraynew.concat(scorearrayprevious);
                    newScoreList.splice(-1,1);

                    //Username
                    usernamearrayprevious = value.username.slice(0, i);
                    usernamearraynew = value.username.slice(i, value.score.length);
                    console.log("values", usernamearrayprevious, usernamearraynew);
                    usernamearrayprevious.push(username);
                    var newUsername = usernamearrayprevious.concat(usernamearraynew);
                    newUsername.splice(-1,1);

                    value.score = newScoreList;
                    value.username = newUsername;

                    db.set("data", value);

                    return true; //break out of the loop using Array.prototype.some by returning true
               }
                i++;
            });
            pubnub.publish({
                "channel": "leaderboard_scores",
                "message": value
            }).then((publishResponse) => {
                console.log("publish response", publishResponse);
            });
        } else {
          //Initial Data
            db.set("data", {
                "username":["---","---","---","---","---","---","---","---","---","---"], 
                "score":["0","0","0","0","0","0","0","0","0","0"]});
        }
    });
    return request.ok();
};