Real-time Online Multiplayer with Godot Engine

Real-time Online Multiplayer
with
by fales
February, 2017

1 Introduction
Goals
Problems
Guidelines
Common techniques
TCP vs UDP
2 Godot Low Level Networking
Server
Client
Problems
Solutions
3 Godot High Level Networking
Server
Client
Optimizations
4 Benet module
5 End
Real-time Online Multiplayer with Godot Engine fales

Introduction Godot Low Level Networking Godot High Level Networking Benet module End
Goals
Having multiple persons playing the same game together, on diﬀerent
machines, through a network.
No apparent input delay: Players must feel like they are playing the
game on their computer
No apparent lag or video delay: Players should experience a good
simulation
No cheaters: Players should not be allowed to do or see anything besides
what allowed by the game

The Internet is not a pipe
This is wrong
This is more like it

Problems
Networks are unreliable (packets can take diﬀerent route and
arrive out of order or get lost)
Networks have limited data rate and can be slow or become
clogged
Networks add delay (even the light takes time, imagine a
decades old copper twisted pair)

Guidelines
There is no one ﬁt all solution.
It really depends on you game. (genre, mechanics, interactions).
There are a few general guidelines
Everything should happen on the server, clients are mere
dummy displays.
Clients should only send their inputs or commands (server
must discard disallowed commands)
Send as little data as possible as often as possible to keep
latency at a minimum for RT games.

Common techniques
UDP Networking
State synchronization
Interpolation
Compression/Size optimizations
Lag compensation
Common techniques

TCP vs UDP
TCP
Connection based
Reliable delivery
Ordered delivery
High latency
UDP
Connectionless
Unreliable delivery
Unordered delivery
Low latency

Godot low level UDP
Echo Server
var _clients = []
var _udp = PacketPeerUDP .new()
func _ready ():
_udp.listen (4321)
set_process (true)
func _process(delta ):
var msgs = []
while _udp. get_available_packet_count () > 0:
var pkt = _udp.get_var () # or get_packet ()
var ip = _udp. get_packet_ip ()
var port = _udp. get_packet_port ()
if _clients.find(ip + ":" + str(port )) == -1:
# New client
_clients.append(ip + ":" + str(port ))
# Prepare message to be broadcasted
msgs.append(ip + ":" + str(port) + "-" + str(pkt ))
# Broadcast messages
for c in _clients:
var splitted = c.split(":")
_udp. set_send_address (splitted [0], int(splitted [1]))
for msg in msgs:
_udp.put_var(msg)

Godot low level UDP
Client
var _udp = PacketPeerUDP .new()
func _ready ():
_udp. set_send_address ("localhost" ,4321)
set_process (true)
func _process(delta ):
var msgs = []
while _udp. get_available_packet_count () > 0:
var pkt = _udp.get_var () # or get_packet ()
msgs.append("Server␣says:␣" + str(pkt ))
# Show messages
for msg in msgs:
print(msg)
func send_data(data ):
_udp.put_var(data) # or put_packet

Problems with UDP
Detect client disconnection (ping/timeout)
Detect out of order packets (time sync)
Detect/resend packet lost if we want it to be reliable
(sequence/acks)

Some solutions
Have the client sends some ping packet, if a ping is not
received by the server for more than X seconds, the client
is considered disconnected
Send and additional time value with packets you want to be
ordered. Keep the last received time, if you receive a lower
time, drop it. (see wrap)
Have the two parties add sequence numbers to pacekets and
send acknowledgment of received data. Keep a queue of
last sent/received packets. Stop sending until you receive an
ack for the lowest missing packet if the new packet has a
sequence number higher than the lowsest plus the ack window
size. Reorder received packets... mess!
Note: have a look at var2bytes and bytes2var

Godot High Level Networking
Based on ENet library (might change in the future or on
speciﬁc platform)
Allow both reliable and unreliable communication over UDP
Based on RPC calls
See http://docs.godotengine.org/en/latest/tutorials/high level multiplayer.html

Godot High Level Networking II
Node network modes:
Master: This node is considered master (this instance owns it)
Slave: This node is considered slave (someone else owns it)
RPC/RSET modes:
sync: called both locally and over network
remote: called only remotely (no matter the owner)
slave: the function will be called only on slave nodes
master: the function will be called only on the master node

Server
func create_server ():
set_network_mode ( NETWORK_MODE_MASTER )
var host = NetworkedMultiplayerENet .new()
host. create_server (4321 , 4)
get_tree (). set_network_peer (host)
var time = 0
func update_remote_state (tick ): # Tick is ideally 20/30 FPS (ie. 0.05/0.03)
var state = []
# Parse the game state
# ... eg.
state.append(get_pos ())
state.append( get_linear_velocity ())
# Send RPC , called on the node with the SAME PATH in the client
time += 1
rpc_unreliable (" update_state ", time , tick , state)
slave func update_state (time , tick , state ):
# ... (see next slide)

Client
func create_client ():
set_network_mode ( NETWORK_MODE_SLAVE )
var client = NetworkedMultiplayerENet .new()
client. create_client ("127.0.0.1", 4321)
get_tree (). set_network_peer (client)
var last_time = 0
slave func update_state (time , tick , state ):
# Handle wrap -around , see rfc1185 as reference
if last_time >= time: # Out of order packet ... drop
return
last_time = time
# Handle state update here eg. tween this object
get_node("Tween"). stop_all ()
get_node("Tween"). interpolate_method (self , "set_pos",
get_pos (), state [0], tick ,
Tween.TRANS_LINEAR , Tween.EASE_IN)
get_node("Tween"). interpolate_method (self , " set_linear_velocity ",
get_linear_velocity (), state [1], tick ,
Tween.TRANS_LINEAR , Tween.EASE_IN)
get_node("Tween"). start ()
Note: the node that makes the RPC MUST have the same node path for in
both server and client for this to work

Optimizations?
Try to bundle homogeneous data in the same state update
(but make sure the maximum packet size will be less than
400-450 bytes, or it might get dropped).
Optimize your state update! (see note, eg. boolean can be 1
byte instead of 4)
Use prediction!
Instead of interpolating recv pos and recv vel, interpolate to recv pos
+ recv vel * tick , and keep predicting till next frame
Note: http://docs.godotengine.org/en/stable/reference/binary serialization api.html

Benet module
Developed to use ENet at full power
Does not use RPC (unless you want to)
Allow for broadcast send (to speciﬁc client)
Uses signals to notify of recv packets, clients
connect/disconnect
Allow for unreliable but ordered channels (you don’t have to
manage time)
Allows multiple channels
Github: https://github.com/Faless/godot-enet-better
Note: will likely not be included in Godot, I’m looking to port it to the C API
by karroﬀel and bojidar-bg when it’s ready

Thanks for your time!
Questions?
Useful link:
http://gaﬀerongames.com/networking-for-game-programmers/
Gaﬀer on Games - Game Networking
https://developer.valvesoftware.com/wiki/Lag compensation
Valve Wiki - Lag compensation
Full working demos in this presentation: https://github.com/Faless/godotcon-multiplayer

Real-time Online Multiplayer with Godot Engine

More Related Content

What's hot (20)

Similar to Real-time Online Multiplayer with Godot Engine (20)

Recently uploaded (20)

Real-time Online Multiplayer with Godot Engine