🚧 This documentation page is a work in progress 🚧
Overview
Godot provides great multiplayer capabilities out of the box. We’ll be using
Godot’s built-in networking along with Rivet’s Godot plugin to build a
server-authoritative multiplayer game on top of Rivet.
Godot supports ENet, WebSocket, and WebRTC transports. We’ll be using ENet for
this tutorial, but it’s easy to swap out.
Step 1: Set up the Rivet Godot plugin
Follow the instructions on the Rivet Godot plugin
repository to install the plugin.
Once the plugin is open, sign in to link your game to Rivet.
Step 2: Update game code
Add the following code to the relevant places.
Add this code to where the game is started:
func _ready():
RivetHelper.start_server.connect(start_server)
RivetHelper.setup_multiplayer()
setup_multiplayer() call will do a check to properly start a Godot. Add this code wherever the server is started. This function name needs to
match
the one used in the RivetHelper.start_server.connect call above.
func start_server():
peer = ENetMultiplayerPeer.new()
peer.create_server(DEFAULT_PORT, MAX_PEERS)
multiplayer.set_multiplayer_peer(peer)
await Rivet.matchmaker.lobbies.ready({})
func join_game(new_player_name):
player_name = new_player_name
var response = await Rivet.matchmaker.lobbies.find({
"game_modes": ["default"]
})
if response.result == OK:
RivetHelper.set_player_token(response.body.player.token)
var port = response.body.ports.default
peer = ENetMultiplayerPeer.new()
peer.create_client(port.hostname, port.port)
multiplayer.set_multiplayer_peer(peer)
else:
game_error.emit(response.body)
Step 3: Deploy to Rivet
Copy the following to rivet.json:
{
"engine": {
"godot": null
},
"matchmaker": {
"max_players": 12,
"docker": {
"dockerfile": "Dockerfile",
"ports": {
"default": {
"port": 10567,
"protocol": "udp"
}
}
},
"game_modes": {
"default": {}
}
}
}
Write Dockerfile
Write the following Dockerfile
FROM ghcr.io/rivet-gg/godot-docker/godot:4.2 AS builder
WORKDIR /app
COPY . .
RUN mkdir -p build/linux \
&& godot -v --export-release "Linux/X11" ./build/linux/game.x86_64 --headless
FROM ubuntu:22.04
RUN apt update -y \
&& apt install -y expect-dev \
&& rm -rf /var/lib/apt/lists/* \
&& useradd -ms /bin/bash rivet
COPY --from=builder /app/build/linux/ /app
# Change to user rivet
USER rivet
# Unbuffer output so the logs get flushed
CMD ["sh", "-c", "unbuffer /app/game.x86_64 --verbose --headless -- --server | cat"]
Deploy game
In the Rivet plugin, we can go to the deploy tab, and select “Staging” from the
dropdown. Then, click “Build & Deploy”. This will build the Dockerfile we just
created, and upload the Docker image to Rivet’s servers.
Deploy game client
Now that we’ve deployed the game to Rivet, we can build a game client that will
be able to connect to Rivet. First, we need to specify which server we want to
connect from the “Playtest” tab. To use the settings that we deployed the server
with above, we need to select “Rivet servers”, and set the namespace to
“Staging”.
Note that changing anything under the “Playtest” tab will require
rebuilding or restarting the game, since the tokens are only set when the game
is starting. This is also something to verify when shipping builds, you don’t
want to upload a version to Steam that tries to connect to your Staging server!
To build the client we can either build through Godot’s export system, or simply
run the game from the editor. Both are configured to get the tokens needed for
the namespace you have set. You don’t need to change anything with how you would
export the game normally for this to work!