added webrtc, pre-4.3 update to fix cyclic dependency

Networking/WSClient/multiplayer_client.gd

@@ -0,0 +1,107 @@
+extends "ws_webrtc_client.gd"
+
+var rtc_mp: WebRTCMultiplayerPeer = WebRTCMultiplayerPeer.new()
+var sealed := false
+
+func _init():
+	connected.connect(self._connected)
+	disconnected.connect(self._disconnected)
+
+	offer_received.connect(self._offer_received)
+	answer_received.connect(self._answer_received)
+	candidate_received.connect(self._candidate_received)
+
+	lobby_joined.connect(self._lobby_joined)
+	lobby_sealed.connect(self._lobby_sealed)
+	peer_connected.connect(self._peer_connected)
+	peer_disconnected.connect(self._peer_disconnected)
+
+
+func start(url, _lobby = "", _mesh:=true):
+	stop()
+	sealed = false
+	self.mesh = _mesh
+	self.lobby = _lobby
+	connect_to_url(url)
+
+
+func stop():
+	multiplayer.multiplayer_peer = null
+	rtc_mp.close()
+	close()
+
+func _create_peer(id):
+	var peer: WebRTCPeerConnection = WebRTCPeerConnection.new()
+	peer.initialize({
+		"iceServers": [ { "urls": ["stun:stun.l.google.com:19302"] } ]
+	})
+	peer.session_description_created.connect(self._offer_created.bind(id))
+	peer.ice_candidate_created.connect(self._new_ice_candidate.bind(id))
+	rtc_mp.add_peer(peer, id)
+	if id < rtc_mp.get_unique_id(): # So lobby creator never creates offers.
+		peer.create_offer()
+	return peer
+
+
+func _new_ice_candidate(mid_name, index_name, sdp_name, id):
+	send_candidate(id, mid_name, index_name, sdp_name)
+
+
+func _offer_created(type, data, id):
+	if not rtc_mp.has_peer(id):
+		return
+	print("created", type)
+	rtc_mp.get_peer(id).connection.set_local_description(type, data)
+	if type == "offer": send_offer(id, data)
+	else: send_answer(id, data)
+
+
+func _connected(id, use_mesh):
+	print("Connected %d, mesh: %s" % [id, use_mesh])
+	if use_mesh:
+		rtc_mp.create_mesh(id)
+	elif id == 1:
+		rtc_mp.create_server()
+	else:
+		rtc_mp.create_client(id)
+	multiplayer.multiplayer_peer = rtc_mp
+
+
+func _lobby_joined(_lobby):
+	self.lobby = _lobby
+
+
+func _lobby_sealed():
+	sealed = true
+
+
+func _disconnected():
+	print("Disconnected: %d: %s" % [code, reason])
+	if not sealed:
+		stop() # Unexpected disconnect
+
+
+func _peer_connected(id):
+	print("Peer connected %d" % id)
+	_create_peer(id)
+
+
+func _peer_disconnected(id):
+	if rtc_mp.has_peer(id): rtc_mp.remove_peer(id)
+
+
+func _offer_received(id, offer):
+	print("Got offer: %d" % id)
+	if rtc_mp.has_peer(id):
+		rtc_mp.get_peer(id).connection.set_remote_description("offer", offer)
+
+
+func _answer_received(id, answer):
+	print("Got answer: %d" % id)
+	if rtc_mp.has_peer(id):
+		rtc_mp.get_peer(id).connection.set_remote_description("answer", answer)
+
+
+func _candidate_received(id, mid, index, sdp):
+	if rtc_mp.has_peer(id):
+		rtc_mp.get_peer(id).connection.add_ice_candidate(mid, index, sdp)

Networking/WSClient/ws_webrtc_client.gd

@@ -0,0 +1,121 @@
+extends Node
+
+enum Message {JOIN, ID, PEER_CONNECT, PEER_DISCONNECT, OFFER, ANSWER, CANDIDATE, SEAL}
+
+@export var autojoin := true
+@export var lobby := "" # Will create a new lobby if empty.
+@export var mesh := true # Will use the lobby host as relay otherwise.
+
+var ws: WebSocketPeer = WebSocketPeer.new()
+var code = 1000
+var reason = "Unknown"
+
+signal lobby_joined(lobby)
+signal connected(id, use_mesh)
+signal disconnected()
+signal peer_connected(id)
+signal peer_disconnected(id)
+signal offer_received(id, offer)
+signal answer_received(id, answer)
+signal candidate_received(id, mid, index, sdp)
+signal lobby_sealed()
+
+
+func connect_to_url(url):
+	close()
+	code = 1000
+	reason = "Unknown"
+	ws.connect_to_url(url)
+
+
+func close():
+	ws.close()
+
+
+func _process(delta):
+	var old_state: int = ws.get_ready_state()
+	if old_state == WebSocketPeer.STATE_CLOSED:
+		return
+	ws.poll()
+	var state = ws.get_ready_state()
+	if state != old_state and state == WebSocketPeer.STATE_OPEN and autojoin:
+		join_lobby(lobby)
+	while state == WebSocketPeer.STATE_OPEN and ws.get_available_packet_count():
+		if not _parse_msg():
+			print("Error parsing message from server.")
+	if state == WebSocketPeer.STATE_CLOSED:
+		code = ws.get_close_code()
+		reason = ws.get_close_reason()
+		disconnected.emit()
+
+
+func _parse_msg():
+	var parsed = JSON.parse_string(ws.get_packet().get_string_from_utf8())
+	if typeof(parsed) != TYPE_DICTIONARY or not parsed.has("type") or not parsed.has("id") or \
+		typeof(parsed.get("data")) != TYPE_STRING:
+		return false
+
+	var msg := parsed as Dictionary
+	if not str(msg.type).is_valid_int() or not str(msg.id).is_valid_int():
+		return false
+
+	var type := str(msg.type).to_int()
+	var src_id := str(msg.id).to_int()
+
+	if type == Message.ID:
+		connected.emit(src_id, msg.data == "true")
+	elif type == Message.JOIN:
+		lobby_joined.emit(msg.data)
+	elif type == Message.SEAL:
+		lobby_sealed.emit()
+	elif type == Message.PEER_CONNECT:
+		# Client connected
+		peer_connected.emit(src_id)
+	elif type == Message.PEER_DISCONNECT:
+		# Client connected
+		peer_disconnected.emit(src_id)
+	elif type == Message.OFFER:
+		# Offer received
+		offer_received.emit(src_id, msg.data)
+	elif type == Message.ANSWER:
+		# Answer received
+		answer_received.emit(src_id, msg.data)
+	elif type == Message.CANDIDATE:
+		# Candidate received
+		var candidate: PackedStringArray = msg.data.split("\n", false)
+		if candidate.size() != 3:
+			return false
+		if not candidate[1].is_valid_int():
+			return false
+		candidate_received.emit(src_id, candidate[0], candidate[1].to_int(), candidate[2])
+	else:
+		return false
+	return true # Parsed
+
+
+func join_lobby(_lobby: String):
+	return _send_msg(Message.JOIN, 0 if mesh else 1, lobby)
+
+
+func seal_lobby():
+	return _send_msg(Message.SEAL, 0)
+
+
+func send_candidate(id, mid, index, sdp) -> int:
+	return _send_msg(Message.CANDIDATE, id, "\n%s\n%d\n%s" % [mid, index, sdp])
+
+
+func send_offer(id, offer) -> int:
+	return _send_msg(Message.OFFER, id, offer)
+
+
+func send_answer(id, answer) -> int:
+	return _send_msg(Message.ANSWER, id, answer)
+
+
+func _send_msg(type: int, id: int, data:="") -> int:
+	return ws.send_text(JSON.stringify({
+		"type": type,
+		"id": id,
+		"data": data
+	}))