Overview

When integrating Metaplay into an existing game, we recommend an incremental adoption of our features. This lets you focus on a few quick wins, for example our LiveOps features, without having to refactor existing game logic.

We'll explain how to implement Metaplay into an existing game with scene management and other pre-existing services. As every game is different, we'll discuss the steps in the context of an endless runner game, but the steps apply to any project.

We intentionally avoided any extensive refactoring or even cleanup of the sample project's structure, as you are unlikely to have the luxury of time for that when working on live games. Of course, the scope of this integration tutorial is just a starting point for adopting what we feel is the true value of Metaplay: a cheat-proof game economy that, from a game design point of view, enables our long-term progression, monetization, and social features.

TIP

The complete integrated sample project is available on GitHub, including setup instructions and ways to explore the code.

Integration Goal

To get to value quickly, we decided to focus on the following goals for the initial integration:

• Cloud Saves - Persist the player's progress in the Metaplay Cloud.
• Segmentation - The ability to create new segments and have players move in and out of those segments during gameplay. This is a fundamental feature to enable targeted live operations.
• Over-the-air LiveOps events - The ability to configure, schedule and target dynamic in-game events directly from the game’s LiveOps Dashboard without requiring Unity client builds.
• Over-the-air game configs - A pipeline to digest game economy configuration from Google Sheets and make new game config “builds” that can be delivered to clients over-the-air without making new Unity client builds.
• A/B testing of game configs - The ability to define alternative values in the above game configs, group them into experiments, and deliver those experiments to specific player segments.
• Rich player state visualization - Custom UIs in the LiveOps Dashboard to make it easier to browse player states in the cloud. This makes the sample project more interesting to look at and, in a real project, would significantly help customer support agents in responding to support tickets.

While implementing the above, we also want to keep the following long-term goals in mind:

• Develop and test locally - The ability to develop and test all of the above features locally (without complicated dependencies) to maintain a productive developer experience.
• Cloud deployments - While not in scope of this tutorial, the resulting game will be ready to be deployed to Metaplay’s managed cloud services for easy testing.
• Cheat proofing - We want to take the first steps towards cheat proofing: items in the shop are populated from the game config and are validated on the server to prevent fake purchases.

Integration Action Plan

Now that we have goals in mind, we can map out the integration steps needed to get there.

Initial Integration and Feature Adoption

The integration process goes through minimal setup of the core SDK, and implementing the specific LiveOps features we want to use.

• Basic integration of the Metaplay SDK - We will add the Metaplay SDK into the project, implementing player logins and basic state persistence. We will intentionally focus only on the minimum effort needed to enable the next steps.
• LiveOps feature adoption - We will integrate the following four LiveOps features from the Metaplay SDK into the example game: over-the-air game configs, segmentation, experiments, and LiveOps events.

Polish and Next Steps

After the initial integration is complete, we will add a bit of extra polish to make the resulting sample more interesting to look at and prepare it for next steps beyond this tutorial.

• LiveOps Dashboard customization - We will initialize a custom LiveOps Dashboard project and add custom UI elements to it to make the player states easier to browse.
• Cheat proofing - We will make use of Metaplay’s cheat-proof programming model to protect the in-game economy by preventing fake purchases.

At the end of the tutorial, the endless runner will have been converted into a game that uses Metaplay for remote configuration, player segmentation, experiments, and scheduling LiveOps events.