Real-time communication is essential for a fun, immersive gaming experience. This is why our dedicated development team is creating a powerful set of tools that make games more immersive, social and interactive.

With ODIN, 4Players provides a complete, out-of-the-box solution that has been designed and built from the ground up for gamers, developers and publishers so you don’t need to spend valuable resources designing a comms solution on your own.

How does it work?#

graph BT
  subgraph ODIN Server
    OR2[Odin Room]
    OR[Odin Room]    
  end
  subgraph Gameserver
    GS[Game Server]
  end
  subgraph Game
    ClientA[Player A] --> OR[ODIN Room]
    ClientB[Player B] --> OR[ODIN Room] 
    ClientB[Player B] --> GS[Game Server]   
    ClientC[Player C] --> GS[Game Server]
    ClientC[Player C] --> OR[ODIN Room] 
    ClientD[Player D] --> GS[Game Server]
  end
  subgraph Lobby
    ClientE[Players E] --> OR2[ODIN Room]
    ClientF[Players F] --> OR2[ODIN Room]
  end      

ODIN Dashboard#

While you can create access keys on the go directly in the SDK or here in the documentation, those access keys are only valid for up to 25 users. If you have subscribed to a paid tier, you can create access keys that handle unlimited users in our dashboard. You can also set limits to manage your budget.

If you have subscribed to a paid tier, we already have created a project for you. You can create multiple access keys for different apps or projects or even external developers - so that you can revoke them once they are finished.

In the dashboard you’ll also find latest stats on your usage and peak number of users.

Go to ODIN Dashboard

Key Benefits#

By integrating ODIN technology into your game, you can enjoy several benefits including:

Cutting Edge Technology#

ODIN is the result from years of expertise and experience. 4Players combines business and industry insight with a very modern technology stack to drive growth for your business.

Easy to Get Started#

Our SDKs include extensive documentation as well as numerous code samples allowing you to get the integration done in just a few days. Shorten time to market by using our best-in-class technology to deliver seamless in-game communication and improve your retention.

Highly Optimized#

We took a lot of effort to make sure you can focus your time and resources on building the game you envisioned. ODIN is highly optimized, so developers can allocate more resources to other features of their game.

Truly Cross-Platform#

ODIN knows no boundaries or limitations and interoperates across platforms ensuring seamless communication and collaboration for users on any device. Our native SDK libraries are available for various desktop operating systems including Microsoft Windows, macOS and Linux as well as mobile devices running iOS or Android. Additionally, we provide integrations for major game engines such as Unity and Unreal Engine All major web browsers are also supported.

Seemless Integration#

Our technology can be fully integrated into any game so players don’t need to interrupt the game experience to switch to a third-party app like TeamSpeak or Discord.

Immersive Gaming without Limits#

In contrast to relying on external apps, integrating comms right into the game allows creating unique, ultra-realistic and immersive gaming experiences. Using features like spatial audio and custom filters, there are no limits to creativity. Plus, there is absolutely no interference with existing technology you might be using.

No Data Mining#

Privacy and security is very important to us. ODIN is completely user agnostic and we don’t harvest any data or tell you how things should work or look. You are in complete control.

Massively Scalable#

Built with flexibility in mind, ODIN scales as your project requirements increase. Chat rooms are created on demand. Whether your game has 10 or 10 million concurrent users, the service just works.

Cloud or On-Premise Hosting#

Choose between a managed cloud and a self-hosted solution. Let us deal with the setup, administration and bandwidth costs or run our server software on your own infrastructure allowing you complete control and customization of your deployment environment. The choice is yours.

Flexible and Cost Effective#

User interaction is vital to building thriving communities within games. As a game developer, you can just download and use the SDK for free for up to 25 concurrently connected users (CCU). Or you can order the Starter package today to be among the first studios to integrate ODIN. For the first 12 months we offer the full toolset with unlimited CCUs for a very small price and a little branding.

Basic Concepts#

Next, we recommend learning more about the basic concepts of ODIN. The basic flow of joining a room and adding media like a microphone to it. Handling events being triggered as other players are joining the same room.

Next: Basic Concepts

Getting started#

Can’t wait to get started and experiencing ODIN? Then stop reading and start digging by following our getting started guide. Choose your platform and you’ll have ODIN up and running withing the next 20 minutes!

You might want to watch this Unreal video tutorial series

or watch this Unity video tutorial series

Unity

Use our deep Unity integration to add the most immersive in-game voice chat to your product with minimal development overhead.

Learn more

Unreal Engine

Our upcoming Unreal Engine plugin will feature full support for all available platforms and come with Blueprint and C++ support.

Learn more

Web Browser

Our NPM package will feature full real-time communication support for all major web browsers including voice activity dectection.

Learn more

Swift

Integrate OdinKit into your iOS and macOS apps and add real-time voice communication in a couple of minutes and with zero maintenance or operations.

Learn more

An access key is your unique authentication key to be used to generate room tokens for accessing the 4Players ODIN server network. Think of it as your individual username and password combination all wrapped up into a single non-comprehendable string of characters, and treat it with the same respect.

While you can create an unlimited number of access keys for your projects, we strongly recommend that you never put an access key in your client code. Please refer to the Examples section to grab some code snippets to help you generate ODIN room rokens in a secure way.

Generating Access Keys#

Every access key is a 44 character long Base64-String, which consists of an internal version mumber, a set of random bytes and a checksum. We’re providing several methods for generating new access keys using our SDKs.

You can create an access key for up to 25 concurrent users for free directly in the widget below.

Using the SDK#

We’re providing several ways to create access keys locally using one of our SDKs. The resulting access keys can be used to access the ODIN network with up to 25 concurrently connected users free of charge.

#include <stdio.h>

#include "odin.h"

int main()
{
  char access_key[128];
  char key_id[64];
  int error;

  error = odin_access_key_generate(access_key, sizeof(access_key));

  if (odin_is_error(error))
  {
    printf("Failed to generate access key; error %d\n", error);
    return 1;
  }

  printf("Your new access key is: %s\n", access_key);

  error = odin_access_key_id(access_key, key_id, sizeof(key_id));

  if (odin_is_error(error))
  {
    printf("Failed to get key ID from access key; error %d\n", error);
    return 1;
  }

  printf("The key ID for your access key is: %s\n", key_id);

  return 0;
}

var odinTokens = require("@4players/odin-tokens")

var accessKey = odinTokens.generateAccessKey();

console.log("Your new access key is: " + accessKey);

var keyPair = odinTokens.loadAccessKey(accessKey);
var keyId = odinTokens.getKeyId(keyPair.publicKey);

console.log("The key ID for your access key is: " + keyId);

If you’ve an active ODIN subscription, contact us, to submit the public key for an existing access key.

With ODIN Command Line Utility#

We provide an NPM based command line utility that you can use to generate an access key. Install it with this command:

> npm install -g @4players/odin-cli

Then, you can use the command line tool in your terminal to generate an access key:

> odin-cli create-access-key

You’ll get a response similar to this one. You can use the access key in all SDKs available.

Your access key:
AQMaxMG2nLNvdUCdHp+lZKfNYKuxs4Vb/O7kPI4rEeX2
Please note: This access key is only valid for up to 25 users and may not be used in production!
Sign up to generate access keys production and/or more users: https://app.tarif-config.4players.de/config/149/en_GB

Flowchart#

The relationships between the individual components of an access key are as follows:

graph LR
  RandomBytes[Random Bytes] --> AccessKey;
  AccessKey[Access Key] --> PublicKey;
  AccessKey --> SecretKey[Secret Key];
  PublicKey[Public Key] --> KeyId[Key ID];

Terminology#

Access Key

Gives access to the ODIN network. It is a 44 character long Base64-String, which consists of a version, random bytes and a checksum.

Secret Key

Generated from the access key, it is based on the Ed25519-Curve and used to sign a room generated by the game developer.

Public Key

Generated from the access key, it is based on the Ed25519-Curve and must be uploaded to 4Players so that a generated room token can be verified.

Key ID

A shortened public key, included in the token, making it possible to identify what public key must be used to verify the room token.

Room Token

A signed JWT given to the game clients that allows them to connect to a voice chat room in the ODIN network.

ODIN has been built from scratch by industry leading voice engineers with your privacy and security in mind. In addition, ODIN provides the following key features:

• Ultra-low latency and extremely low resource usage
• Best-in-class voice quality with noise suppression
• Built-in data protection and fully GDPR compliant
• Support for thousands of concurrent users chatting at the same time with native 3D spatial audio support
• Deep Unity and Unreal Engine integration
• Zero maintenance and operations for clients but support for self-hosting if they want to (for sensitive areas)

This table should give you an overview how ODIN compares to other solutions.

We have compiled a couple of standard use-cases for ODIN and show you which benefits ODIN has to offer. So let’s get started:

Basic concepts#

It’s important to understand the basic concept of ODIN:

graph BT
  subgraph ODIN Server
    OR2[Odin Room 1]
    OR[Odin Room 2]        
  end
  subgraph Mobile
    ClientA[Client D] <--> OR
    ClientB[Client C] <--> OR
  end
  subgraph Desktop 
    ClientB[Client C] <--> OR2   
    ClientC[Client B] <--> OR2
  end
  subgraph Consoles*
    ClientD[Client A] <--> OR2
  end

ODIN is a cloud-based client-server application that can easily be integrated into any game or application and even the web. All clients (i.e. users) connected to the same room can chat with all users in that room. Some users may not send any audio and just listening (i.e. spectator). Users also can connect to multiple rooms at the same time and it’s up to you to send audio to all rooms or just one of them.

Multiplayer games#

With its 3D positional audio and deep engine integration ODIN is best suited for shooters and battle royal games. But also hide & seek games and many other multiplayer first person or third person games or even virtual reality and augmented reality video conferencing solutions.

Let’s consider a game with these features:

• Multiplayer shooter game
• Two gameplay modes: Team Based (like in CounterStrike or Rainbow Six Siege) and Deathmatch (last man standing)
• Private team chat: All users sharing a team can talk to other team members
• World chat. The voice and sound from players should also be “leaked” into the world.
• Lobby where players can hang around to find team members and to just chat

Now, we’ll have a look at the network topology of such a game. It might be a bit confusing first, but it’s basically very simple. We hope you read on if we say that you can implement these voice chat features production ready within one day - no registration required!

graph LR
  subgraph ODIN Server
    direction RL
    OR3[Room Lobby]
    OR[Room A_Team_A]        
    OR2[Room A_Team_B]
    World[Room A_World]                                   
    World2[Room B_World]                                   
  end  
  subgraph Team A on GS A
    PlayerB[Player B] <--> OR       
    PlayerB[Player B] <--> World       
    PlayerC[Player C] <--> OR 
    PlayerC[Player C] <--> World 
  end    
  subgraph Team B on GS A
    PlayerE[Player D] <--> World     
    PlayerE[Player D] <--> OR2 
    PlayerF[Player E] <--> World         
    PlayerF[Player E] <--> OR2      
  end      
  subgraph Deathmatch on GS B
    PlayerI[Player F] <--> World2
    PlayerJ[Player G] <--> World2
  end  
  subgraph Lobby
    PlayerH[Player A] <--> OR3
  end      
  subgraph Gameserver Fleet
    GS[Gameserver A] --> PlayerB
    GS[Gameserver A] --> PlayerC
    GS[Gameserver A] --> PlayerE
    GS[Gameserver A] --> PlayerF
    GS2[Gameserver B] --> PlayerI
    GS2[Gameserver B] --> PlayerJ
  end

As you have learned in Basic Concepts all users connected to the same room will be able to talk to anyone else in that room. A room in ODIN is just a string. It can be anything and a room is created dynamically if the first player connects to that room and is deleted once the last user has left the room:

• You don’t need to do any book keeping
• Figure out a good algorithm to deterministically create a text string out of your game logic so that users that join the same room that should be able to chat together.

In this example, we use the string Lobby for all players running the game but not playing yet. Of course, you could have different rooms within the lobby like Welcome and Finding_Players.

Next, we have players B - E that are playing on Gameserver A in two different teams. For each team, a room has been created which is a string concatenated from the Name of the Gameserver (could be an IP address and Port for example) and the Team Name which is A_Team_A and A_Team_B. Just connect to that room like this and all team members will be able to chat together.

OdinHandler.Instance.JoinRoom("A_Team_A");

The next thing we need to add is the world chat. Check out this image to understand what we mean with that:

In real world, when people talk to other people via headphones, other people around can hear what that person is saying. This is what we mean with “World chat”. You can just connect all players to another room called A_World for the “world” they are in. And now, other players will be able to listen to what you are saying to your team members. So, better don’t scream and make sure nobody is listening.

So, our code would look like this:

OdinHandler.Instance.JoinRoom("A_Team_A");
OdinHandler.Instance.JoinRoom("A_World");

And if someone changes the team, you’d use these two lines:

OdinHandler.Instance.LeaveRoom("A_Team_A");
OdinHandler.Instance.JoinRoom("A_Team_B");

Unity or Unreal do all the heavy lifting of 3D audio calculation for us. Game engines automatically do the 3D spatial audio effects for us. And we can use standard game engine audio features like mixers and DSP to create fancy audio effects like echo (in large rooms) or signal noise to make the players experience even more realistic.

Sounds interesting? Then get started for free and without registration:

Begin Getting Started Guide

MMOs#

Massively multiplayer online games are very easy to implement with ODIN. You can have the same network topology as seen above for multiplayer games. As MMOs typically have huge worlds they often have some sort of segmentation.

We’d love to play a game like this:

• Space MMO
• Every solar system has its own gameserver (for segmentation) and players can jump from one solar system to another via worm wholes (i.e. does not take much time to transfer from one solar system to another)
• The clue is, that every player has a radio installed with 5 channels, and they can talk to all other players in that channel - independently of their position in the galaxy.
• Players can also call friends in a direct chat.

Let’s have a look at the network topology if this game (radio channels 3 - 5 omitted for clarity):

graph LR
  subgraph ODIN Server
    direction RL
    C1[Room Radio_Channel_1]                                     
    C2[Room Radio_Channel_2]                                   
    DC[Room DirectChat_FG]                                   
  end  
  subgraph In Game
    PlayerH[Player A] <--> C1
    PlayerB[Player B] <--> C1              
    PlayerC[Player C] <--> C1 
    PlayerF[Player D] <--> C2
    PlayerE[Player E] <--> C2                   
    PlayerI[Player F] <--> DC
    PlayerJ[Player G] <--> DC
  end   
  subgraph Gameserver Fleet
    GS[Solar System A] --> PlayerH
    GS[Solar System A] --> PlayerB
    GS[Solar System A] --> PlayerC    
    GS[Solar System A] --> PlayerF
    GS2[Solar System B] --> PlayerE    
    GS2[Solar System B] --> PlayerI
    GS2[Solar System B] --> PlayerJ
  end

As you can see, ODIN is completely independent of your multiplayer topology. This allows you to quickly find the best approach of voice communication within your game without constantly refactoring your client server architecture. ODIN is a pure client side implementation and thus easy to implement!

In the diagram above we have this “game state”:

• Players A-D are in Solar System A, while players E-G are in Solar System B.
• Players D and E are talking in the same radio, although they are on different game servers and therefore solar systems.
• Players A-C talk in radio channel 1.
• Players F-G have a direct chat.

Direct Chat#

For the direct chat feature we have created a simple room name with DirectChat_FG, which is just a string concatenated from the fixed keyword DirectChat_ and then the ID or name of Players A and Player B. Both players are connected to that room like this (pseudo code):

class Player
{
    private void GetPlayerID()
    {
        return netID;
    }
    
    public void CallPlayer(Player otherPlayer)
    {
        // Join direct chat room
        string roomName = "DirectChat_" + this.GetPlayerID() + otherPlayer.GetPlayerID();
        OdinHandler.Instance.JoinRoom(roomName);
        
        // Signal the client of the other player to join the same room
        otherPlayer.RoomJoinRequest(this, roomName);
    }
    
    public void RoomJoinRequest(Player otherPlayer, string roomName)
    {
        // Show "Ring Notification"
        UI.ShowIncomingCallNotification(otherPlayer.name, roomName);                
    }
    
    public void OnAcceptIncomingCall(string roomName)
    {
        // Signal the client of the other player to join the same room
        OdinHandler.Instance.JoinRoom(roomName);
    }
}

That’s it. It’s as easy as figuring out a good string, connecting to a room and then signaling the other client an incoming call. The other client is showing a UI with a button to accept the call. If accepted the other client joins the same room, and they can talk. Hanging up is just leaving the room!

Radio with different channels#

This is easy to do. The Player has a UI where he can set the radio channel. For each radio channel we just create a simple string like Radio_Channel_1 and Radio_Channel_2. When a player changes the radio channel, we just need to leave the current room and connect the other room:

class Radio
{
    private string _currentRadio = null;
    
    public void OnRadioChannelChanged(int channel)
    {
        if (_currentRadio != null) {
            OdinHandler.Instance.LeaveRoom(_currentRadio);
        }
        
        _currentRadio = "Radio_Channel_" + channel.ToString();
        OdinHandler.Instance.JoinRoom(_currentRadio);        
    }      
}

Sounds interesting? Then get started for free and without registration:

Begin Getting Started Guide

Open World#

Open world games are awesome, because they give gamers so much freedom, however, those are not so easy to implement. At least the voice part will be very easy to do.

In this example, we have two players running around a huge map. ODIN can handle thousands of users in one room with ease. The deep engine integration of ODIN enables developers to leverage the skills they already have and don’t need to learn something new.

All you have to do is to “through” all players in the same room. ODIN servers know where the players are in 3D space and can route voice packets only to those players that are close enough. This way, CPU on client side is only spent on voice that happens nearby. Network bandwidth is also only used for the necessary audio packets with zero overhead.

Our deep engine integration does not require you to do anything? Just join a room on client side, handle a couple of callbacks and that’s all.

Volume will change with the distance between the players and with headphones or stereo speakers they’ll hear the direction where the other player is. It’s an immersive experience for your players!

Sounds interesting? Then get started for free and without registration:

Begin Getting Started Guide

VR and AR#

VR games and applications need to be as immersive and realistic as possible to prevent users from getting motion sick and to feel strange when the headset is on. While this is of course true for graphics, it’s even more important for audio. Headset creators have spent a lot of efforts in creating good headphones and audio solutions for their devices, let’s make use of them!

Voice chat in VR (and to some extend in AR) is even more important than screen based gaming, as typing in VR is an awkward experience and voice is the only way to chat with other people efficiently. And it’s much more immersive, too.

Build virtual conferences, cinemas, multiplayer games and many more with ODIN and real-time 3D audio. In VR, performance is key, and ODIN with its deep engine integration is best suited for these kind of experiences.

Sounds interesting? Then get started for free and without registration:

Begin Getting Started Guide

Virtual Conferences / Metaverse#

An important vision these days is the metaverse. The idea is to build virtual spaces that allow people to do everything in the virtual world that they can do in the real world. But without the constraints of the real world. Beaming yourself in seconds to every place you imagine: in our lifetime that will not going to happen, but in virtual world, that’s not an issue at all.

One key feature of the metaverse is audio chats. It’s key and core feature. And spatial 3D audio - i.e. the voice of someone standing nearby is loader than someone else a couple of feet away, and the voice is coming from the direction the person is related to the listener. These are the core features of ODIN and can be implemented in minutes.

The metaverse is the vision, virtual conferences for example is one very good example for that. Surfing web pages on virtual conferences is boring and the feeling of visiting other people and companies is not there. Virtual offices or conferences where people can run around having “virtual physical meetings” is one way to replicate a more physical presence. However, it must be natural. You should be able to chat with everyone you see, but you should also be able to have a discreet one-to-one chat with someone else. And without the hassle of managing contact lists, calling other users and all those complexities that come with standard voice chat tools.

In this example use-case we have built a virtual conference, featuring different rooms. Users are running around and can listen and talk to everyone they see. As it is in the real world.

We use ODINs spatial 3D audio. Every user joining the conference will join a global 3D ODIN room. This way, they can listen to the “noise” of other people talking and listening. Users can of course disable that room if they want to, however, the feeling of presence also includes some sort of noise and randomly hearing other people discussing and talking.

graph BT
  subgraph ODIN Server
    BR[Blue Room]
    YR[Yellow Room]
    FC[Floor Chat]        
    DC[Direct Chat A/B]        
  end
  subgraph Members
    ClientA[Member A] <--> DC    
    ClientB[Member B] <--> DC
    ClientB[Member B] <--> FC   
    ClientD[Member D] <--> YR
    ClientE[Member E] <--> YR
    ClientF[Member F] <--> YR
    ClientG[Member G] <--> FC
    ClientI[Member I] <--> FC
    ClientJ[Member J] <--> FC
    ClientC[Member C] <--> BR
  end

But, there are some benefits that don’t exist in the real world:

Silent direct chats. In noisy environments, it can be hard to have a direct chat. In our virtual world, two (or more) members standing on the floor can join a direct chat. They start talking in the public floor chat, then if they decide to have a private chat, one member invites the other member to join a private conversation, and if the other one agrees, they will join a private randomly created room. Users can still keep their connection to the floor chat (dampened with lower volume) so that they still hear what is going on outside and can react if someone reaches out to them, but they will be able to easily focus on the private conversation.

Next, we have virtual meeting rooms. These are spaces that have a separate ODIN room, that means, whenever you walk into that virtual space, the user will automatically join another ODIN room only available for those people within that virtual space.

In this example, we have that “blue” room and a “yellow” room. Every user walking into that space triggers a collider which then joins the room. Of course you can use ODINs access key feature to only allow specific users to join that room. It will be a secure connection and only those (unlike in the real world) that have the permissions will be able to listen to that chat.

Once users walk out of this space, they leave the ODIN room and will join the global 3D audio room again to participate in the public chat.

You can build these kind of applications with just a couple lines of code (pseudo code!):

class VirtualConferenceMember
{
    public void Start()
    {
        // Join public floor chat
        OdinHandler.Instance.JoinRoom("Floor_Chat");
    }
    
    public void OnTrigger(Collider collider)
    {
        if (collider.collision.direction == Collider.Direction.Entering) {
          // Join private room and leave public "floor" chat
          OdinHandler.Instance.JoinRoom(collider.name);
          OdinHandler.Instance.LeaveRoom("Floor_Chat");
        } else if (collider.collision.direction == Collider.Direction.Exiting) {
          // Leave private room and join public floor chat
          OdinHandler.Instance.LeaveRoom(collider.name);
          OdinHandler.Instance.JoinRoom("Floor_Chat");
        }        
    }      
}

Sounds interesting? Then get started for free and without registration:

Begin Getting Started Guide

Singleplayer games#

One use-case for Singleplayer games is “support”. Sometimes players get stuck at specific locations within the game. You can use our Web based framework to integrate ODIN into your web based community like your Forum. Within your game you could place a “Get help” button. If a player clicks on that button, the player will be connected to the same room as community members connected using the web app. The game can also leverage User Data to provide the exact level and location to the community, so they can quickly help! You can even create a simple bot, that listens on OnPeerJoined events and sends a push notification to all community members via web push notifications that are not currently joined to the ODIN room.

graph BT
  subgraph ODIN Server
    OR[Odin Room]        
  end
  subgraph Game
    ClientA[Player A] <--> OR
  end
  subgraph Web App
    ClientB[Community A] <--> OR   
    ClientC[Community B] <--> OR 
    ClientD[Community C] <--> OR
  end
  subgraph Notification
    Script[Bot] <--> OR   
  end    

Sounds interesting? Then get started for free and without registration:

Begin Getting Started Guide

Hosting type#

Managed#

With ODIN managed cloud hosting, for each subscription, you have an individual project with an infinite number of access keys ( see Understanding Access Keys ). Each project then represents its own room namespace where people can talk to each other.

On-Premise#

When using an ODIN on-premise server, in combination with an ODIN gateway for easy scalability, you can configure everything the way you need it. You can assign namespaces on either a customer level or for each individual access key.

Organizing your projects#

As an active subscriber you can manage your projects here:

Go to ODIN Dashboard

There you can manage your keys for all the cloud hosted projects you currently have. Keys for on-premise projects you can manage in your own configuration files.

Separating rooms by project#

Each project has his own namespace. If in both projects there is a room named “lobby”, users from one project will not be able to talk to users from the other project, even if both users joined a room named “lobby”.

graph TD
    subgraph ODIN Clients
        subgraph Project 1
            C1[Client 1]
        end
        subgraph Project 2
            C2[Client 2]
        end
    end

    C1 -->|Yes| R1
    C2 -->|Yes| R2
    C2 -.->|No| R1
    
    subgraph ODIN Server
        subgraph Project 1
            R1["Room #quot;lobby#quot;"]
        end    
        subgraph Project 2
            R2["Room #quot;lobby#quot;"]
        end
    end
    
    R1 -.-|cannot talk to each other| R2
 

Separating rooms within one project#

You can also keep things simple and separate users by choosing special room IDs in the same namespace, e.g. “lobby_server1” and “lobby_server2”. But depending on where your room tokens are generated (server-side or client-side) or if clients are able to decide themselves, which room ID to use for joining, you will have to make compromises with security.

graph TD
    subgraph ODIN Clients
        subgraph Project 1
            C1[Client connected to server 1]
            C2[Client connected to server 2]
        end
    end
    
    subgraph ODIN Server
        subgraph Project 1
            R1["Room #quot;lobby_server1#quot;"]
            R2["Room #quot;lobby_server2#quot;"]
        end
    end
    
    C1 -->|Yes| R1
    C2 -->|Yes| R2
    C1 -->|should not| R2

    R1-.-|cannot talk to each other| R2

ODIN is a client server platform. Servers are hosted by 4Players, but can also be hosted by clients. The whole system is stateless and scalable. There are no databases keeping track of everything, instead everything just relies on stateless connections and some tokens that are used during authentication.

Topology#

This diagram outlines the basic structure of two clients connected to an ODIN server. Client 1 has joined two rooms listening and talking and Client 2 has also joined room 2 but is just listening there.

graph TB;
    subgraph ODIN Server
        Connection1[Connection 1]
        Connection2[Connection 2]
    end
    Client1[Client 1] -- Authenticate --> Connection1
    Client2[Client 2] -- Authenticate --> Connection2
    subgraph Room1[Room 1]
        Peer11[Peer 1] -- StartMedia --> MediaStream111[Media Stream 1]
    end
    subgraph Room2[Room 2]
        Peer21[Peer 1] -- StartMedia --> MediaStream211[Media Stream 1]
        Peer21[Peer 1] -- StartMedia --> MediaStream212[Media Stream 2]
        Peer22[Peer 2]
    end    
    Connection1 -- JoinRoom --> Peer11
    Connection1 -- JoinRoom --> Peer21
    Connection2 -- JoinRoom --> Peer22    

Every client connects an ODIN server and authenticates with an access token and joins a room. Once the client has joined a room, he is a peer inside the ODIN room. Every peer can add media to that room, linked to a physical device like a microphone. Clients can join multiple rooms at the same time and can add multiple media streams at the same time.

Connecting to Server#

The first step is to connect to a server and a room. If you are using one of our high level SDKs like Unity or Unreal joining a room is all you have to do. The SDK handles authentication and server connection for you.

sequenceDiagram

participant Local
participant Server
participant Remote

Local ->>+ Server: Authenticate
Server -->>- Local: Success

Local ->>+ Server: JoinRoom
Server ->> Remote: PeerJoined
Server -->>- Local: Success

Local --> Server: Opening Room Stream
Server ->> Local: Joined

Once the connection is established and the room has joined an event is sent to all other peers in the same room: PeerJoined. This allows you to update your UI for example like showing a list of peers that are within a room.

The client who joined the room will receive a RoomJoin and RoomJoined event. If a user clicks a button to join a room, you can use the RoomJoin event to start showing a loading indicator and hiding it once RoomJoined has been triggered.

Event summary#

• Unity
• Unreal

Local	Remote	Description
OnRoomJoin		Triggered if user started to join a room
OnRoomJoined	OnPeerJoined	Triggered if user joined a room

ODIN does not require any bookkeeping. A room is created automatically for the first connection and will be removed whenever the last user left the room. You join a room by calling the JoinRoom method of the OdinHandler instance in your scene.

class MyVoiceHandler: MonoBehaviour
{
  public string RoomName = "default";
  
  // Start is called before the first frame update
  void Start()
  {
    OdinHandler.Instance.JoinRoom(RoomName);
  }
}

Local	Remote	Description
On Room Joined	On Peer Joined	Triggered if user joined a room

ODIN does not require any bookkeeping. A room is created automatically for the first connection and will be removed whenever the last user left the room. You join a room by calling the Join Room function in your blueprint.

Info

Please note: To join a room you need to create an access token. The whole process is described in the Unreal Engine Manual.

Joining a room looks like this:

Event handling looks like this:

Starting a media#

As defined above, every peer connected to a room can (but does not have to) add a media, i.e. a stream connected to the peers’ input device, e.g. a microphone. Please note: Every peer can add multiple media to the same room (i.e. audio and video). In Contrary, you can not use the same media twice, e.g. for 2 different rooms.

sequenceDiagram

participant Local
participant Server
participant Remote

Local ->>+ Server: AddMedia
Server ->> Remote: MediaAdded
Server -->>- Local: Success

The local OdinHandler will trigger OnCreatedMediaObject once the request media has been added to the server. OnMediaAdded is triggered for media added by other peers to the room.

Event summary#

• Unity
• Unreal

Local	Remote	Description
OnCreatedMediaObject	OnMediaAdded	Triggered once the media has been added to the room on the server

Info

It’s important to handle the OnMediaAdded callbacks. Whenever you receive this event, you need to call the AddPlaybackComponent method on your OdinHandler instance which will create a PlaybackComponent and assign to a GameObject that corresponds to this peer in Odin.

Local	Remote	Description
On Add Media To Room Success	On Media Added	Triggered once the media has been added to the room on the server

Info

It’s important to handle the On Media Added event. Whenever you receive this event, you need to assign the media to an Odin Synth Component that is either part of the asset (added at design time) or you can also create that component with Add Odin Synth Component in your blueprint. The Odin Synth Component generates audio output from the incoming media stream.

Adding a media looks like this:

Stopping a media#

Users can mute their audio streams, in this case, the media stream should be stopped, so that no data is captured and to ODIN servers. Of course, also leaving a room can lead to stopped media.

sequenceDiagram

participant Local
participant Server
participant Remote

Local ->>+ Server: StopMedia
Server ->> Remote: MediaStopped
Server -->>- Local: Success

The MediaStopped event will be triggered once the request media has been deleted on the server.

Event summary#

• Unity

Updating Peer User Data#

Every peer in Unity can store arbitrary information as user data. When local user data is updated, the server updates user data at all clients and sends this message. Read more about user data in our guide: Understanding User Data.

sequenceDiagram

participant Local
participant Server
participant Remote

Local ->>+ Server: UpdateUserData
Server ->> Remote: PeerUpdated
Server -->>- Local: Success

Whenever a peer updates his data, all other peers receive the PeerUpdated event to handle the new data.

Event summary#

• Unity

Sending Arbitrary Data#

You can use ODIN to send arbitrary data to other clients. You can use this method to build simple multiplayer games that don’t require complex, real-time movement. For many casual games or board games, this message is enough to sync the players positions and other information of the game state with all clients.

The data you can send is basically just an array of bytes. You can use any data serialization that makes sense to you. Many game engines already provide data serialization features.

sequenceDiagram

participant Local
participant Server
participant Remote

Local ->>+ Server: SendMessage
Server ->> Remote: MessageReceived
Server -->>- Local: Success

Event Summary#

• Unity

Disconnecting#

If peers disconnect other peers will be notified with the PeerLeft events.

sequenceDiagram

participant Local
participant Server
participant Remote

Local -->+ Server: Closing Connection
Server ->> Remote: PeerLeft
deactivate Server

Event Summary#

• Unity

Getting Kicked#

If a peer is kicked from the server, this message flow will take place:

sequenceDiagram

participant Local
participant Server
participant Remote

activate Server
Server ->> Local: Left
Server ->> Remote: PeerLeft
Server --> Local: Closing Connection
deactivate Server

Event Summary#

• Unity
• Unreal

Next Steps#

Curious enough? Then get started with our Getting Started Guides. Choose your platform and start coding. It’ll only take 20 minutes to play around with ODIN right in your game engines editor: Getting Started.

Getting Started with ODIN

Still not convinced or wanting to learn more? We have compiled a couple of use cases and how ODIN is best suited to handle them perfectely, being it a First Person Shooter or a MMO Battle Royal Game.

Next: Use Cases

We provide a free web client that you can use to test your ODIN integration. It’s a simple yet powerful web app built on top of our Web SDK that we use internally to test our SDKs. It allows you to connect to any ODIN room and communicate with others. As ODIN is fully cross platform, you can also use the Web SDK to test your Unreal or Unity integration.

Prerequisites#

• An ODIN access key. Read this guide to learn how to generate an access key.
• A modern browser like Chrome, Firefox or Safari.
• A microphone (optional)
• A pair of headphones or speakers

Data structures used#

ODIN gives you full flexibility with its user data structure. You can use it to store any data you want on each peer. The Web Client uses this structure to show the users name, the version of the client and the platform it is running on. It’s a JSON object, i.e. you need to encode a JSON Object to a byte array and set that as the user data. Please note: This is fully optional - it’s just “eye candy”. The Web Client will show any peer connected to the room - if no user data in this form has been provided it will just title it “Unknown User”.

export interface Avatar {
  data: string,
  seed: string
}

export interface UserData {
  name: string,
  avatar: Avatar,
  userId: string,
  outputMuted: number,
  inputMuted: number,
  platform: string,
  version: string
}

Using the Web Client#

The Web Client is available at https://app.odin.4players.io/. When launching the app, you’ll see a screen like this:

Setting your Access Key#

The first thing you need to do is to set your access key. You can do this by clicking on the small gear icon next to the connect button - that is important as you want to use the same access key you use for your app, game or website. If access keys don’t match users will not be able to communicate with each other.

Joining a room#

Enter the room and the same gateway as you use in your app, game or website. You can also enter a name. The web client will fill out the data structure for user data described above. If your integration insists on a specific user data you might need to work around that a bit.

The click on the Connect button to join the room.

User Manual#

The Web Client is pretty straight forward. You can mute your microphone and speakers by clicking on the icons in the bottom left control panel. On the left you’ll see all other users connected to the room. The web client also features a simple text chat and video chat.

Troubleshooting#

Make sure that you use the same access key and room name as you use in your own integration. It’s always wise to douple check the correct entry of the access key.

Support#

Please note, that we don’t provide support for this tool - as we use it internally for testing purposes it typically uses the latest SDK and server version - so if you experience any issues, please check if you use the latest version of the SDK and server. Please also make sure, that you entered your access key in the field Access Key and not the Access Token. The AccessToken field is just used if you don’t use a gateway but connect directly to an ODIN server.