Now Any Game Developer Can Enable Cross-Game Player Identities and Friends Lists. Here’s How.

Historically, cross-game social functionality has been reserved exclusively for game publishing giants, that is, until now.

“Functionality like cross-game friends lists has historically been the exclusive domain of huge companies or platforms with near-unlimited resources. With Ready, any developer can provide this type of AAA functionality to their players — and without the limitation of having friends constrained to a single hardware platform or game.״ — KJ Mercer, Ready’s lead game designer.

Until today, any indie game developer, or even small to mid-tier publishers, would attest that building cross-game reputations and social profiles for their players are way out of their league. Now any publisher, regardless of size or stature, can easily allow this authentication functionality with a few simple SDK integrations. Ready Games’ cross-game player identities bear multifold benefits to span all aspects of the player and developer experience.

Ready’s User Authentication Module allows players to create and log in to their RGN accounts from any device with an email and password, with all player progress saved non-locally to preserve player XP no matter what.

Email-based login player authentication integration is as follows:

using RGN.Modules.SignIn;

namespace SomeNamespace
{
    internal sealed class EmailLoginLogout
    {
        public void EmailSignIn()
        {
            // This call will open a web form
            // Handle the result in RGNCore.I.AuthenticationChanged event callback
            EmailSignInModule.I.TryToSignIn();
        }
        public void EmailSignOut()
        {
            EmailSignInModule.I.SignOut();
        }
    }
}

Ready’s authentication reaches beyond the capabilities of even the big-name publishers by enabling next-gen web3 functionality integrated in an intuitive way that appeals to the immediate needs of the users with web3 solutions and allows them to access those solutions in a way that is familiar, intuitive, and seamless.

Certain aspects of web3 functionality can be exceedingly profitable for game developers and players alike if implemented in the right way. Ready Games guides developers to implement this functionality in a way that does not sacrifice the convenience and userbase of conventional gaming while introducing new features for everyone to enjoy.

Key Benefits

There are tons of benefits associated with Ready’s universal player authentication model for players and developers alike. Here are a few of the main benefits and why they are important.

Simple Sign-In

Players choose an email and password to create an account. The simplicity and familiarity of email sign-in create an intuitive experience for all players.

Casual, Mobile-Friendly NFTs & Crypto Wallet

It’s not just the sign-in process that is streamlined; Ready’s authentication model has simplified and streamlined the crypto wallet creation process to be intuitive and unintimidating for all players.

Take, for example, the case in which a player has just purchased or earned an NFT in a game but does not yet hold a crypto wallet. If the player has an RGN account, they can be prompted to create a wallet through an intuitive in-game pop-up like this:

Simple in-game player wallet creation

Restore Game Progress

Players who uninstall a game can pick back up where they left off by logging in with their RGN account. No lost progress! This functionality is especially important for players who have made non-consumable purchases.

Support for Multiple Devices

With RGN authentication, games can be played on any device by simply signing in with RGN login credentials. Players can seamlessly switch between devices while keeping their progress consistent.

Cross-Game Friend Lists

If your game has multiplayer or social components and a friends feature, players who log in with a RGN account will automatically have access to their friends list in all of their social games. For example, Alice is friends with Bob in Game A. They log in to Game B with the same credentials they used in Game A. Bob and Alice are now in each other’s friends list in Game B!

Integrating RGN Player Authentication

Once RGN SDK is initialized, integrating Ready Games Player authentication functionality is simple. The first step is to subscribe to the RGNCore.I.AuthenticationChanged event to handle authentication and retrieve user data.

Since the RGNCore.I.AuthenticationChangedevent is handled in the RGNUnityInitilizer component, it is recommended to use the RGNUnityInitilizer component to initialize the RGN SDK.

It should be noted that on SignIn with any Auth Provider, credentials are stored in Keystore(Android) & Keychain(IOS) files.

Subscribe Authentication Changed Event

using RGN;
using RGN.Modules.GameProgress;
using RGN.Modules.SignIn;
using RGN.Modules.UserProfile;
using UnityEngine;

namespace SomeNamespace
{
    internal sealed class SomeMonoBehaviour : MonoBehaviour
    {
        private void OnEnable()
        {
            RGNCore.I.AuthenticationChanged += OnAuthenticationChangedAsync;
        }
        private void OnDisable()
        {
            RGNCore.I.AuthenticationChanged -= OnAuthenticationChangedAsync;
        }

        private async void OnAuthenticationChangedAsync(
            EnumLoginState enumLoginState,
            EnumLoginError error)
        {
            switch (enumLoginState)
            {
                case EnumLoginState.Error:
                    Debug.LogError("On Auth error: " + enumLoginState +
                        ", error: " + error);
                    break;
                case EnumLoginState.Success:
                    var userProfileData =
                        await UserProfileModule.I.
                            GetFullUserProfileAsync<GameUserFullProfileData>(
                                RGNCore.I.MasterAppUser.UserId);
                    Debug.Log("User logged in \n" +
                             "UserId :" + userProfileData.userId + "\n" +
                             "Display Name :" + userProfileData.displayName + "\n" +
                             "Short UID :" + userProfileData.shortUID + "\n");
                    // TODO: Load other data from here
                    break;
                case EnumLoginState.NotLoggedIn:
                    Debug.Log("User is not logged in");
                    GuestSignInModule.I.TryToSignIn();
                    break;
                default:
                    Debug.LogError("Unhandled Login State: " + enumLoginState);
                    break;
            }
        }
    }
}

When the user logs out from any provider, they are automatically logged in with Guest provider. This is built to store the user progress and make sure the user can switch to email later and track their progress.

Guest Login/Logout

using RGN.Modules.SignIn;

namespace SomeNamespace
{
    internal sealed class GuestLoginLogout
    {
        public void GuestLogin()
        {
            GuestSignInModule.I.TryToSignIn();
        }
        public void GuestLogout()
        {
            GuestSignInModule.I.SignOut();
        }
    }
}

Ready Games Public SDK

Ready Games is making next-gen game creation and feature integration seamless for developers, studios, and publishers in order to make way for a better, more universal gaming experience for all players by integrating web3 technologies in an intuitive and compliant manner. Ready’s SDK is public for all to see, and open for all game developers to implement. Create an account to get started and unlock early-adopter developer benefits and rewards.