Architecture

Core concept

In a nutshell, the interaction with Idem happens in three steps:

1. A player is added to the service
2. Idem reponds with a match suggestion for the player
3. The match result is reported to Idem so we update the rating and ranking of the involved players

Core concept

Based on that simple interaction, Idem takes care of:

• Rating and ranking
• Leaderboard
• Player stats
• Usage stats (e.g. by time of day, region, ...)

... and much more.

By default, the communication happens via WebSocket. For quickstart and development purposes, we also offer a REST API.

Architecture types

There are two different architecture types for integrating Idem with a game, server-based and player-based. The key question to identify the right one for your game is:

Does your game have a backend server that manages game clients (→ Server-based)
or
should your game clients connect to Idem directly (→ Player-based)?

For more details on how to choose the right architecture, see the Choose your architecture section below.

Player-based

If you are considering the player-based architecture, this means that you either do not have a game backed or you don't want it to orchestrate players and servers. To enable this, game clients communicate directly with Idem in this architecture. When a match suggestion is created by Idem, we request to host a game server at a server hosting provider (ADD LINK) of your choice. Once we recieve the server join info for the server from the server hosting provider, we forward it to each player who is part of the suggested match.

Based on it's nature of game clients not going through a backend server, the player-based architecture includes additional components for an optimized experience. These include:

• Integration with authentication providers (e.g. Steam and Firebase) for securing your matchmaking queues
• Integration with lobby services (e.g. Unity and Steam) to allow players to be matched with their friends as a party

The overall player-based architecture looks like this:

Player-based architecture

You can learn all about implementing the player-based architecture here.

Server-based

In the server-based architecture, the communication with Idem happens centrally from your backend. This means that game clients will connect to your backend and the backend will orchestrate them and send request to idem for them. In most cases, the game back is also taking care of hosting game servers. The overall architecture looks like this:

Server-based architecture

If you want to outsurce managing the server hosting, Idem can take care of that for you. In that case, Idem will communicate directly with a server hosting provider (ADD LINK) of your choice and request a server to be hosted for each match. Once we receive the server join info from the server hosting provider, we forward it to your backend so it can be shared with the game clients.

The corresponding architecture looks like this:

Server-based architecture with game server hosting via idem

You can learn all about implementing the server-based architecture here.

Choose your architecture

As mentioned above, the most important question is who will be communicating with Idem - a backend or the game clients themselves. Sinve Idem only requires communication via WebSocket or REST, it supports any kind of game-backend, whether self-built or 3rd party Game-Backend-as-a-Service (GBaaS).

Own backend

If you are building your own backend, you simply connect that backend to Idem via WebSocket or REST. This also applies if you are using a 3rd party game backend for certain aspects of your game backend (e.g. collectibles), but you handle player orchestration with your own code.

Your architecture → Server-based

Third party backend (GBaaS)

We have reference implementations and tutorials for a number of popular GBaaS. If you are using one of them, it will be a breeze to integrate it with Idem. You can check out the list here.

If the GBaaS you are using is not on the list yet, please get in touch at support@idem.gg. We are continously adding integrations with additional GBaaS, so it might be supported soon. But even if not, by following the instructions for the player-based architecture, you can easily integrate with any backend. Our integrations just remove some steps from that process.

Your architecture → Server-based

Note: If you are only using GBaaS for functions not related to matchmaking, see Own backend.

No backend
If your game does not use a backend at all, player-based is the archtecture for you.

Your architecture → Player-based