Shape Tag

Some code for WebRTC if you wanna learn:

Signaling server (js):

import WebSocket, { WebSocketServer } from "ws";

const wss = new WebSocketServer({ port: 9396 });

const messages = {
ASSIGN_ID: 0,
JOIN_LOBBY: 1,
PLAYERS_FOUND: 2,
SEND_ICE_CANDIDATE: 3,
SEND_DESCRIPTION: 4,
RECEIVE_ICE_CANDIDATE: 5,
RECEIVE_DESCRIPTION: 6,

};

let players = {};

let waiting_players = [];

let waiting_player_ids = [];

let next_player_id = 2;

const PLAYERS_IN_GAME = 3;

wss.on("connection", function connection(ws) {
const player_id = next_player_id;
players[player_id] = ws;
next_player_id += 1;

ws.on("close", function close() {
delete players[player_id];
console.log("Player left :(");
});

ws.on("error", console.error);

ws.on("message", function message(data) {
try {
const json_data = JSON.parse(data);
console.log(JSON.stringify(json_data));
if (json_data.message == messages.JOIN_LOBBY) {
console.log("Player wants to join lobby.");
waiting_players.push(ws);
waiting_player_ids.push(player_id);
if (waiting_players.length >= PLAYERS_IN_GAME) {
console.log("Lobby found!");
console.log(waiting_players);
/*
let lowest_id = -1;
for (let i = 0; i < PLAYERS_IN_GAME; i++) {
if (waiting_player_ids[i] < lowest_id || lowest_id == -1) {
lowest_id = waiting_player_ids[i];
}
}
for (let i = 0; i < PLAYERS_IN_GAME; i++) {
if (waiting_player_ids[i] == lowest_id) {
waiting_player_ids[i] = 1;
}
}
*/
for (let i = 0; i < PLAYERS_IN_GAME; i++) {
console.log(waiting_players[i]);
waiting_players[i].send(
JSON.stringify({
message: messages.PLAYERS_FOUND,
players: waiting_player_ids,
})
);
}
waiting_players = [];
waiting_player_ids = [];
}
}
if (json_data.message == messages.SEND_ICE_CANDIDATE) {
players[json_data.target].send(
JSON.stringify({
message: messages.RECEIVE_ICE_CANDIDATE,
from: player_id,
mid_name: json_data.mid_name,
index_name: json_data.index_name,
sdp_name: json_data.sdp_name,
})
);
}
if (json_data.message == messages.SEND_DESCRIPTION) {
console.log(json_data);
players[json_data.target].send(
JSON.stringify({
message: messages.RECEIVE_DESCRIPTION,
from: player_id,
data: json_data.data,
type: json_data.type,
})
);
}
} catch (e) {
console.log('Got strange data: "' + data + '"');
console.error(e);
}
});
ws.send(JSON.stringify({ message: messages.ASSIGN_ID, id: player_id }));

});

Client signaling (gdscript):

extends Node

class_name Signaling

@onready var web_rtc_manager : WebRTCManager = $"../WebRTC"

@onready var network_manager : NetworkManager = get_parent()

var socket = WebSocketPeer.new()

var waiting_for_join_request : bool = false

var my_id : int

var is_host : bool

var host_id : int = -1

enum messages {

ASSIGN_ID,

JOIN_LOBBY,

PLAYERS_FOUND,

SEND_ICE_CANDIDATE,

SEND_DESCRIPTION,

RECEIVE_ICE_CANDIDATE,

RECEIVE_DESCRIPTION,

}

func _ready():

socket.connect_to_url("ws://localhost:9396")

waiting_for_join_request = true

func _process(_delta):

socket.poll()

var state = socket.get_ready_state()

if state == WebSocketPeer.STATE_OPEN:

if waiting_for_join_request:

socket.send_text(JSON.stringify({"message":messages.JOIN_LOBBY}))

waiting_for_join_request = false

while socket.get_available_packet_count():

var packet_data : Dictionary = JSON.parse_string(socket.get_packet().get_string_from_utf8())

if packet_data.message == messages.ASSIGN_ID:

my_id = packet_data.id

web_rtc_manager.my_id = my_id

network_manager.id = my_id

web_rtc_manager.connected(my_id)

elif packet_data.message == messages.PLAYERS_FOUND:

web_rtc_manager.players_in_game = len(packet_data.players)

is_host = true

for player_id : int in packet_data.players:

web_rtc_manager.connect_to_player(player_id)

if player_id > my_id:

is_host = false

if player_id < host_id or host_id == -1:

host_id = player_id

network_manager.is_host = is_host

network_manager.host_id = host_id

print(packet_data.players)

print("Found players!")

elif packet_data.message == messages.RECEIVE_ICE_CANDIDATE:

web_rtc_manager.add_ice_candidate(packet_data.mid_name, packet_data.index_name, packet_data.sdp_name, packet_data.from)

elif packet_data.message == messages.RECEIVE_DESCRIPTION:

web_rtc_manager.set_remote_description(packet_data.type, packet_data.data, packet_data.from)

elif state == WebSocketPeer.STATE_CLOSING:

# Keep polling to achieve proper close.

pass

elif state == WebSocketPeer.STATE_CLOSED:

var code = socket.get_close_code()

var reason = socket.get_close_reason()

print("WebSocket closed with code: %d, reason %s. Clean: %s" % [code, reason, code != -1])

set_process(false) # Stop processing.

func send(message : messages, data : Dictionary, target : int):

data["message"] = message

data["target"] = target

socket.send_text(JSON.stringify(data))

func send_description(type : String, data : String, target : int):

send(messages.SEND_DESCRIPTION, {"data": data, "type": type}, target)

func send_ice_candidate(mid_name, index_name, sdp_name, target : int):

send(messages.SEND_ICE_CANDIDATE, {"mid_name":mid_name, "index_name":index_name, "sdp_name":sdp_name}, target)

WebRTC manager (gdscript):

extends Node

class_name WebRTCManager

@onready var signaling : Signaling = $"../Signaling"

var peer : WebRTCMultiplayerPeer = WebRTCMultiplayerPeer.new()

var my_id : int

var players_in_game : int

var connected_peers : int = 0

func _ready():

multiplayer.peer_connected.connect(peer_connected)

func connect_to_player(id : int):

var player_peer : WebRTCPeerConnection = WebRTCPeerConnection.new()

player_peer.initialize({

"iceServers" : [{ "urls": ["stun:stun.l.google.com:19302"] }]

})

player_peer.session_description_created.connect(offer_created.bind(id))

player_peer.ice_candidate_created.connect(ice_candidate_created.bind(id))

peer.add_peer(player_peer, id)

if id < my_id:

player_peer.create_offer()

func offer_created(type : String, data : String, id : int):

signaling.send_description(type, data, id)

func ice_candidate_created(mid_name, index_name, sdp_name, id : int):

signaling.send_ice_candidate(mid_name, index_name, sdp_name, id)

func add_ice_candidate(mid_name, index_name, sdp_name, id : int):

peer.get_peer(id).connection.add_ice_candidate(mid_name, index_name, sdp_name)

func set_remote_description(type : String, data : String, id : int):

peer.get_peer(id).connection.set_remote_description(type, data)

func connected(id):

peer.create_mesh(id)

multiplayer.multiplayer_peer = peer

func peer_connected(id):

print("Connection with " + str(id))

connected_peers += 1

if connected_peers == players_in_game - 1:

get_parent().connected_to_everyone()

@rpc("any_peer", "call_local")

func ping():

print("I got pinged!")

func _on_ping_button_pressed():

ping.rpc()

Yes, it's kinda complicated but it works.