Multiplayer networking renames/simplification

Removes _networking_ prefix from some methods and members, now that multiplayer has been largely moved out of Node and SceneTree and is seperated into its own set of classes.

5 files changed, 134 insertions, 134 deletions

diff --git a/core/multiplayer/multiplayer.h b/core/multiplayer/multiplayer.h
index 8ddad61dd0..00c81d3c9a 100644
--- a/core/multiplayer/multiplayer.h
+++ b/core/multiplayer/multiplayer.h
@@ -45,8 +45,8 @@ enum TransferMode {
 
 enum RPCMode {
 	RPC_MODE_DISABLED, // No rpc for this method, calls to this will be blocked (default)
-	RPC_MODE_ANY, // Any peer can call this rpc()
-	RPC_MODE_AUTHORITY, // / Only the node's network authority (server by default) can call this rpc()
+	RPC_MODE_ANY, // Any peer can call this RPC
+	RPC_MODE_AUTHORITY, // / Only the node's multiplayer authority (server by default) can call this RPC
 };
 
 struct RPCConfig {
diff --git a/core/multiplayer/multiplayer_api.cpp b/core/multiplayer/multiplayer_api.cpp
index 1130fcf9cb..9543f77c1e 100644
--- a/core/multiplayer/multiplayer_api.cpp
+++ b/core/multiplayer/multiplayer_api.cpp
@@ -56,22 +56,22 @@ void MultiplayerAPI::profile_bandwidth(const String &p_inout, int p_size) {
 #endif
 
 void MultiplayerAPI::poll() {
-	if (!network_peer.is_valid() || network_peer->get_connection_status() == MultiplayerPeer::CONNECTION_DISCONNECTED) {
+	if (!multiplayer_peer.is_valid() || multiplayer_peer->get_connection_status() == MultiplayerPeer::CONNECTION_DISCONNECTED) {
 		return;
 	}
 
-	network_peer->poll();
+	multiplayer_peer->poll();
 
-	if (!network_peer.is_valid()) { // It's possible that polling might have resulted in a disconnection, so check here.
+	if (!multiplayer_peer.is_valid()) { // It's possible that polling might have resulted in a disconnection, so check here.
 		return;
 	}
 
-	while (network_peer->get_available_packet_count()) {
-		int sender = network_peer->get_packet_peer();
+	while (multiplayer_peer->get_available_packet_count()) {
+		int sender = multiplayer_peer->get_packet_peer();
 		const uint8_t *packet;
 		int len;
 
-		Error err = network_peer->get_packet(&packet, len);
+		Error err = multiplayer_peer->get_packet(&packet, len);
 		if (err != OK) {
 			ERR_PRINT("Error getting packet!");
 			break; // Something is wrong!
@@ -81,11 +81,11 @@ void MultiplayerAPI::poll() {
 		_process_packet(sender, packet, len);
 		remote_sender_id = 0;
 
-		if (!network_peer.is_valid()) {
+		if (!multiplayer_peer.is_valid()) {
 			break; // It's also possible that a packet or RPC caused a disconnection, so also check here.
 		}
 	}
-	if (network_peer.is_valid() && network_peer->get_connection_status() == MultiplayerPeer::CONNECTION_CONNECTED) {
+	if (multiplayer_peer.is_valid() && multiplayer_peer->get_connection_status() == MultiplayerPeer::CONNECTION_CONNECTED) {
 		replicator->poll();
 	}
 }
@@ -107,36 +107,36 @@ Node *MultiplayerAPI::get_root_node() {
 	return root_node;
 }
 
-void MultiplayerAPI::set_network_peer(const Ref<MultiplayerPeer> &p_peer) {
-	if (p_peer == network_peer) {
+void MultiplayerAPI::set_multiplayer_peer(const Ref<MultiplayerPeer> &p_peer) {
+	if (p_peer == multiplayer_peer) {
 		return; // Nothing to do
 	}
 
 	ERR_FAIL_COND_MSG(p_peer.is_valid() && p_peer->get_connection_status() == MultiplayerPeer::CONNECTION_DISCONNECTED,
 			"Supplied MultiplayerPeer must be connecting or connected.");
 
-	if (network_peer.is_valid()) {
-		network_peer->disconnect("peer_connected", callable_mp(this, &MultiplayerAPI::_add_peer));
-		network_peer->disconnect("peer_disconnected", callable_mp(this, &MultiplayerAPI::_del_peer));
-		network_peer->disconnect("connection_succeeded", callable_mp(this, &MultiplayerAPI::_connected_to_server));
-		network_peer->disconnect("connection_failed", callable_mp(this, &MultiplayerAPI::_connection_failed));
-		network_peer->disconnect("server_disconnected", callable_mp(this, &MultiplayerAPI::_server_disconnected));
+	if (multiplayer_peer.is_valid()) {
+		multiplayer_peer->disconnect("peer_connected", callable_mp(this, &MultiplayerAPI::_add_peer));
+		multiplayer_peer->disconnect("peer_disconnected", callable_mp(this, &MultiplayerAPI::_del_peer));
+		multiplayer_peer->disconnect("connection_succeeded", callable_mp(this, &MultiplayerAPI::_connected_to_server));
+		multiplayer_peer->disconnect("connection_failed", callable_mp(this, &MultiplayerAPI::_connection_failed));
+		multiplayer_peer->disconnect("server_disconnected", callable_mp(this, &MultiplayerAPI::_server_disconnected));
 		clear();
 	}
 
-	network_peer = p_peer;
+	multiplayer_peer = p_peer;
 
-	if (network_peer.is_valid()) {
-		network_peer->connect("peer_connected", callable_mp(this, &MultiplayerAPI::_add_peer));
-		network_peer->connect("peer_disconnected", callable_mp(this, &MultiplayerAPI::_del_peer));
-		network_peer->connect("connection_succeeded", callable_mp(this, &MultiplayerAPI::_connected_to_server));
-		network_peer->connect("connection_failed", callable_mp(this, &MultiplayerAPI::_connection_failed));
-		network_peer->connect("server_disconnected", callable_mp(this, &MultiplayerAPI::_server_disconnected));
+	if (multiplayer_peer.is_valid()) {
+		multiplayer_peer->connect("peer_connected", callable_mp(this, &MultiplayerAPI::_add_peer));
+		multiplayer_peer->connect("peer_disconnected", callable_mp(this, &MultiplayerAPI::_del_peer));
+		multiplayer_peer->connect("connection_succeeded", callable_mp(this, &MultiplayerAPI::_connected_to_server));
+		multiplayer_peer->connect("connection_failed", callable_mp(this, &MultiplayerAPI::_connection_failed));
+		multiplayer_peer->connect("server_disconnected", callable_mp(this, &MultiplayerAPI::_server_disconnected));
 	}
 }
 
-Ref<MultiplayerPeer> MultiplayerAPI::get_network_peer() const {
-	return network_peer;
+Ref<MultiplayerPeer> MultiplayerAPI::get_multiplayer_peer() const {
+	return multiplayer_peer;
 }
 
 void MultiplayerAPI::_process_packet(int p_from, const uint8_t *p_packet, int p_packet_len) {
@@ -221,10 +221,10 @@ void MultiplayerAPI::_process_simplify_path(int p_from, const uint8_t *p_packet,
 	packet.write[1] = valid_rpc_checksum;
 	encode_cstring(pname.get_data(), &packet.write[2]);
 
-	network_peer->set_transfer_channel(0);
-	network_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
-	network_peer->set_target_peer(p_from);
-	network_peer->put_packet(packet.ptr(), packet.size());
+	multiplayer_peer->set_transfer_channel(0);
+	multiplayer_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
+	multiplayer_peer->set_target_peer(p_from);
+	multiplayer_peer->put_packet(packet.ptr(), packet.size());
 }
 
 void MultiplayerAPI::_process_confirm_path(int p_from, const uint8_t *p_packet, int p_packet_len) {
@@ -300,10 +300,10 @@ bool MultiplayerAPI::_send_confirm_path(Node *p_node, NodePath p_path, PathSentC
 		ofs += encode_cstring(path.get_data(), &packet.write[ofs]);
 
 		for (int &E : peers_to_add) {
-			network_peer->set_target_peer(E); // To all of you.
-			network_peer->set_transfer_channel(0);
-			network_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
-			network_peer->put_packet(packet.ptr(), packet.size());
+			multiplayer_peer->set_target_peer(E); // To all of you.
+			multiplayer_peer->set_transfer_channel(0);
+			multiplayer_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
+			multiplayer_peer->put_packet(packet.ptr(), packet.size());
 
 			psc->confirmed_peers.insert(E, false); // Insert into confirmed, but as false since it was not confirmed.
 		}
@@ -470,10 +470,10 @@ Error MultiplayerAPI::decode_and_decompress_variant(Variant &r_variant, const ui
 void MultiplayerAPI::_add_peer(int p_id) {
 	connected_peers.insert(p_id);
 	path_get_cache.insert(p_id, PathGetCache());
-	if (is_network_server()) {
+	if (is_server()) {
 		replicator->spawn_all(p_id);
 	}
-	emit_signal(SNAME("network_peer_connected"), p_id);
+	emit_signal(SNAME("peer_connected"), p_id);
 }
 
 void MultiplayerAPI::_del_peer(int p_id) {
@@ -488,7 +488,7 @@ void MultiplayerAPI::_del_peer(int p_id) {
 		PathSentCache *psc = path_send_cache.getptr(E);
 		psc->confirmed_peers.erase(p_id);
 	}
-	emit_signal(SNAME("network_peer_disconnected"), p_id);
+	emit_signal(SNAME("peer_disconnected"), p_id);
 }
 
 void MultiplayerAPI::_connected_to_server() {
@@ -505,8 +505,8 @@ void MultiplayerAPI::_server_disconnected() {
 
 Error MultiplayerAPI::send_bytes(Vector<uint8_t> p_data, int p_to, Multiplayer::TransferMode p_mode, int p_channel) {
 	ERR_FAIL_COND_V_MSG(p_data.size() < 1, ERR_INVALID_DATA, "Trying to send an empty raw packet.");
-	ERR_FAIL_COND_V_MSG(!network_peer.is_valid(), ERR_UNCONFIGURED, "Trying to send a raw packet while no network peer is active.");
-	ERR_FAIL_COND_V_MSG(network_peer->get_connection_status() != MultiplayerPeer::CONNECTION_CONNECTED, ERR_UNCONFIGURED, "Trying to send a raw packet via a network peer which is not connected.");
+	ERR_FAIL_COND_V_MSG(!multiplayer_peer.is_valid(), ERR_UNCONFIGURED, "Trying to send a raw packet while no multiplayer peer is active.");
+	ERR_FAIL_COND_V_MSG(multiplayer_peer->get_connection_status() != MultiplayerPeer::CONNECTION_CONNECTED, ERR_UNCONFIGURED, "Trying to send a raw packet via a multiplayer peer which is not connected.");
 
 	if (packet_cache.size() < p_data.size() + 1) {
 		packet_cache.resize(p_data.size() + 1);
@@ -516,11 +516,11 @@ Error MultiplayerAPI::send_bytes(Vector<uint8_t> p_data, int p_to, Multiplayer::
 	packet_cache.write[0] = NETWORK_COMMAND_RAW;
 	memcpy(&packet_cache.write[1], &r[0], p_data.size());
 
-	network_peer->set_target_peer(p_to);
-	network_peer->set_transfer_channel(p_channel);
-	network_peer->set_transfer_mode(p_mode);
+	multiplayer_peer->set_target_peer(p_to);
+	multiplayer_peer->set_transfer_channel(p_channel);
+	multiplayer_peer->set_transfer_mode(p_mode);
 
-	return network_peer->put_packet(packet_cache.ptr(), p_data.size() + 1);
+	return multiplayer_peer->put_packet(packet_cache.ptr(), p_data.size() + 1);
 }
 
 void MultiplayerAPI::_process_raw(int p_from, const uint8_t *p_packet, int p_packet_len) {
@@ -533,7 +533,7 @@ void MultiplayerAPI::_process_raw(int p_from, const uint8_t *p_packet, int p_pac
 		uint8_t *w = out.ptrw();
 		memcpy(&w[0], &p_packet[1], len);
 	}
-	emit_signal(SNAME("network_peer_packet"), p_from, out);
+	emit_signal(SNAME("peer_packet"), p_from, out);
 }
 
 bool MultiplayerAPI::is_cache_confirmed(NodePath p_path, int p_peer) {
@@ -574,27 +574,27 @@ Node *MultiplayerAPI::get_cached_node(int p_from, uint32_t p_node_id) {
 	return node;
 }
 
-int MultiplayerAPI::get_network_unique_id() const {
-	ERR_FAIL_COND_V_MSG(!network_peer.is_valid(), 0, "No network peer is assigned. Unable to get unique network ID.");
-	return network_peer->get_unique_id();
+int MultiplayerAPI::get_unique_id() const {
+	ERR_FAIL_COND_V_MSG(!multiplayer_peer.is_valid(), 0, "No multiplayer peer is assigned. Unable to get unique ID.");
+	return multiplayer_peer->get_unique_id();
 }
 
-bool MultiplayerAPI::is_network_server() const {
-	return network_peer.is_valid() && network_peer->is_server();
+bool MultiplayerAPI::is_server() const {
+	return multiplayer_peer.is_valid() && multiplayer_peer->is_server();
 }
 
-void MultiplayerAPI::set_refuse_new_network_connections(bool p_refuse) {
-	ERR_FAIL_COND_MSG(!network_peer.is_valid(), "No network peer is assigned. Unable to set 'refuse_new_connections'.");
-	network_peer->set_refuse_new_connections(p_refuse);
+void MultiplayerAPI::set_refuse_new_connections(bool p_refuse) {
+	ERR_FAIL_COND_MSG(!multiplayer_peer.is_valid(), "No multiplayer peer is assigned. Unable to set 'refuse_new_connections'.");
+	multiplayer_peer->set_refuse_new_connections(p_refuse);
 }
 
-bool MultiplayerAPI::is_refusing_new_network_connections() const {
-	ERR_FAIL_COND_V_MSG(!network_peer.is_valid(), false, "No network peer is assigned. Unable to get 'refuse_new_connections'.");
-	return network_peer->is_refusing_new_connections();
+bool MultiplayerAPI::is_refusing_new_connections() const {
+	ERR_FAIL_COND_V_MSG(!multiplayer_peer.is_valid(), false, "No multiplayer peer is assigned. Unable to get 'refuse_new_connections'.");
+	return multiplayer_peer->is_refusing_new_connections();
 }
 
-Vector<int> MultiplayerAPI::get_network_connected_peers() const {
-	ERR_FAIL_COND_V_MSG(!network_peer.is_valid(), Vector<int>(), "No network peer is assigned. Assume no peers are connected.");
+Vector<int> MultiplayerAPI::get_peer_ids() const {
+	ERR_FAIL_COND_V_MSG(!multiplayer_peer.is_valid(), Vector<int>(), "No multiplayer peer is assigned. Assume no peers are connected.");
 
 	Vector<int> ret;
 	for (Set<int>::Element *E = connected_peers.front(); E; E = E->next()) {
@@ -624,32 +624,32 @@ void MultiplayerAPI::_bind_methods() {
 	ClassDB::bind_method(D_METHOD("set_root_node", "node"), &MultiplayerAPI::set_root_node);
 	ClassDB::bind_method(D_METHOD("get_root_node"), &MultiplayerAPI::get_root_node);
 	ClassDB::bind_method(D_METHOD("send_bytes", "bytes", "id", "mode", "channel"), &MultiplayerAPI::send_bytes, DEFVAL(MultiplayerPeer::TARGET_PEER_BROADCAST), DEFVAL(Multiplayer::TRANSFER_MODE_RELIABLE), DEFVAL(0));
-	ClassDB::bind_method(D_METHOD("has_network_peer"), &MultiplayerAPI::has_network_peer);
-	ClassDB::bind_method(D_METHOD("get_network_peer"), &MultiplayerAPI::get_network_peer);
-	ClassDB::bind_method(D_METHOD("get_network_unique_id"), &MultiplayerAPI::get_network_unique_id);
-	ClassDB::bind_method(D_METHOD("is_network_server"), &MultiplayerAPI::is_network_server);
+	ClassDB::bind_method(D_METHOD("has_multiplayer_peer"), &MultiplayerAPI::has_multiplayer_peer);
+	ClassDB::bind_method(D_METHOD("get_multiplayer_peer"), &MultiplayerAPI::get_multiplayer_peer);
+	ClassDB::bind_method(D_METHOD("set_multiplayer_peer", "peer"), &MultiplayerAPI::set_multiplayer_peer);
+	ClassDB::bind_method(D_METHOD("get_unique_id"), &MultiplayerAPI::get_unique_id);
+	ClassDB::bind_method(D_METHOD("is_server"), &MultiplayerAPI::is_server);
 	ClassDB::bind_method(D_METHOD("get_remote_sender_id"), &MultiplayerAPI::get_remote_sender_id);
-	ClassDB::bind_method(D_METHOD("set_network_peer", "peer"), &MultiplayerAPI::set_network_peer);
 	ClassDB::bind_method(D_METHOD("poll"), &MultiplayerAPI::poll);
 	ClassDB::bind_method(D_METHOD("clear"), &MultiplayerAPI::clear);
 
-	ClassDB::bind_method(D_METHOD("get_network_connected_peers"), &MultiplayerAPI::get_network_connected_peers);
-	ClassDB::bind_method(D_METHOD("set_refuse_new_network_connections", "refuse"), &MultiplayerAPI::set_refuse_new_network_connections);
-	ClassDB::bind_method(D_METHOD("is_refusing_new_network_connections"), &MultiplayerAPI::is_refusing_new_network_connections);
+	ClassDB::bind_method(D_METHOD("get_peers"), &MultiplayerAPI::get_peer_ids);
+	ClassDB::bind_method(D_METHOD("set_refuse_new_connections", "refuse"), &MultiplayerAPI::set_refuse_new_connections);
+	ClassDB::bind_method(D_METHOD("is_refusing_new_connections"), &MultiplayerAPI::is_refusing_new_connections);
 	ClassDB::bind_method(D_METHOD("set_allow_object_decoding", "enable"), &MultiplayerAPI::set_allow_object_decoding);
 	ClassDB::bind_method(D_METHOD("is_object_decoding_allowed"), &MultiplayerAPI::is_object_decoding_allowed);
 	ClassDB::bind_method(D_METHOD("get_replicator"), &MultiplayerAPI::get_replicator);
 
 	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "allow_object_decoding"), "set_allow_object_decoding", "is_object_decoding_allowed");
-	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "refuse_new_network_connections"), "set_refuse_new_network_connections", "is_refusing_new_network_connections");
-	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "network_peer", PROPERTY_HINT_RESOURCE_TYPE, "MultiplayerPeer", PROPERTY_USAGE_NONE), "set_network_peer", "get_network_peer");
+	ADD_PROPERTY(PropertyInfo(Variant::BOOL, "refuse_new_connections"), "set_refuse_new_connections", "is_refusing_new_connections");
+	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "multiplayer_peer", PROPERTY_HINT_RESOURCE_TYPE, "MultiplayerPeer", PROPERTY_USAGE_NONE), "set_multiplayer_peer", "get_multiplayer_peer");
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "root_node", PROPERTY_HINT_RESOURCE_TYPE, "Node", PROPERTY_USAGE_NONE), "set_root_node", "get_root_node");
-	ADD_PROPERTY_DEFAULT("refuse_new_network_connections", false);
+	ADD_PROPERTY_DEFAULT("refuse_new_connections", false);
 	ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "replicator", PROPERTY_HINT_RESOURCE_TYPE, "MultiplayerReplicator", PROPERTY_USAGE_NONE), "", "get_replicator");
 
-	ADD_SIGNAL(MethodInfo("network_peer_connected", PropertyInfo(Variant::INT, "id")));
-	ADD_SIGNAL(MethodInfo("network_peer_disconnected", PropertyInfo(Variant::INT, "id")));
-	ADD_SIGNAL(MethodInfo("network_peer_packet", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::PACKED_BYTE_ARRAY, "packet")));
+	ADD_SIGNAL(MethodInfo("peer_connected", PropertyInfo(Variant::INT, "id")));
+	ADD_SIGNAL(MethodInfo("peer_disconnected", PropertyInfo(Variant::INT, "id")));
+	ADD_SIGNAL(MethodInfo("peer_packet", PropertyInfo(Variant::INT, "id"), PropertyInfo(Variant::PACKED_BYTE_ARRAY, "packet")));
 	ADD_SIGNAL(MethodInfo("connected_to_server"));
 	ADD_SIGNAL(MethodInfo("connection_failed"));
 	ADD_SIGNAL(MethodInfo("server_disconnected"));
diff --git a/core/multiplayer/multiplayer_api.h b/core/multiplayer/multiplayer_api.h
index acabda62e2..1fb0318403 100644
--- a/core/multiplayer/multiplayer_api.h
+++ b/core/multiplayer/multiplayer_api.h
@@ -82,7 +82,7 @@ private:
 		Map<int, NodeInfo> nodes;
 	};
 
-	Ref<MultiplayerPeer> network_peer;
+	Ref<MultiplayerPeer> multiplayer_peer;
 	Set<int> connected_peers;
 	int remote_sender_id = 0;
 	int remote_sender_override = 0;
@@ -112,8 +112,8 @@ public:
 	void clear();
 	void set_root_node(Node *p_node);
 	Node *get_root_node();
-	void set_network_peer(const Ref<MultiplayerPeer> &p_peer);
-	Ref<MultiplayerPeer> get_network_peer() const;
+	void set_multiplayer_peer(const Ref<MultiplayerPeer> &p_peer);
+	Ref<MultiplayerPeer> get_multiplayer_peer() const;
 
 	Error send_bytes(Vector<uint8_t> p_data, int p_to = MultiplayerPeer::TARGET_PEER_BROADCAST, Multiplayer::TransferMode p_mode = Multiplayer::TRANSFER_MODE_RELIABLE, int p_channel = 0);
 
@@ -135,15 +135,15 @@ public:
 	void _connection_failed();
 	void _server_disconnected();
 
-	bool has_network_peer() const { return network_peer.is_valid(); }
-	Vector<int> get_network_connected_peers() const;
+	bool has_multiplayer_peer() const { return multiplayer_peer.is_valid(); }
+	Vector<int> get_peer_ids() const;
 	const Set<int> get_connected_peers() const { return connected_peers; }
 	int get_remote_sender_id() const { return remote_sender_override ? remote_sender_override : remote_sender_id; }
 	void set_remote_sender_override(int p_id) { remote_sender_override = p_id; }
-	int get_network_unique_id() const;
-	bool is_network_server() const;
-	void set_refuse_new_network_connections(bool p_refuse);
-	bool is_refusing_new_network_connections() const;
+	int get_unique_id() const;
+	bool is_server() const;
+	void set_refuse_new_connections(bool p_refuse);
+	bool is_refusing_new_connections() const;
 
 	void set_allow_object_decoding(bool p_enable);
 	bool is_object_decoding_allowed() const;
diff --git a/core/multiplayer/multiplayer_replicator.cpp b/core/multiplayer/multiplayer_replicator.cpp
index 0340e11288..17af2c5ef8 100644
--- a/core/multiplayer/multiplayer_replicator.cpp
+++ b/core/multiplayer/multiplayer_replicator.cpp
@@ -113,18 +113,18 @@ Error MultiplayerReplicator::_sync_all_default(const ResourceUID::ID &p_scene_id
 		ERR_CONTINUE(err);
 		ofs += size;
 	}
-	Ref<MultiplayerPeer> network_peer = multiplayer->get_network_peer();
-	network_peer->set_target_peer(p_peer);
-	network_peer->set_transfer_channel(0);
-	network_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_UNRELIABLE);
-	return network_peer->put_packet(ptr, ofs);
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	peer->set_target_peer(p_peer);
+	peer->set_transfer_channel(0);
+	peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_UNRELIABLE);
+	return peer->put_packet(ptr, ofs);
 }
 
 void MultiplayerReplicator::_process_default_sync(const ResourceUID::ID &p_id, const uint8_t *p_packet, int p_packet_len) {
 	ERR_FAIL_COND_MSG(p_packet_len < SYNC_CMD_OFFSET + 5, "Invalid spawn packet received");
 	ERR_FAIL_COND_MSG(!replications.has(p_id), "Invalid spawn ID received " + itos(p_id));
 	SceneConfig &cfg = replications[p_id];
-	ERR_FAIL_COND_MSG(cfg.mode != REPLICATION_MODE_SERVER || multiplayer->is_network_server(), "The defualt implementation only allows sync packets from the server");
+	ERR_FAIL_COND_MSG(cfg.mode != REPLICATION_MODE_SERVER || multiplayer->is_server(), "The defualt implementation only allows sync packets from the server");
 	const bool same_size = p_packet[0] & BYTE_OR_ZERO_FLAG;
 	int ofs = SYNC_CMD_OFFSET;
 	int time = p_packet[ofs];
@@ -233,11 +233,11 @@ Error MultiplayerReplicator::_send_default_spawn_despawn(int p_peer_id, const Re
 		memcpy(&ptr[ofs], pba.ptr(), state_len);
 	}
 
-	Ref<MultiplayerPeer> network_peer = multiplayer->get_network_peer();
-	network_peer->set_target_peer(p_peer_id);
-	network_peer->set_transfer_channel(0);
-	network_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
-	return network_peer->put_packet(ptr, ofs + state_len);
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	peer->set_target_peer(p_peer_id);
+	peer->set_transfer_channel(0);
+	peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
+	return peer->put_packet(ptr, ofs + state_len);
 }
 
 void MultiplayerReplicator::_process_default_spawn_despawn(int p_from, const ResourceUID::ID &p_scene_id, const uint8_t *p_packet, int p_packet_len, bool p_spawn) {
@@ -513,21 +513,21 @@ Error MultiplayerReplicator::_send_spawn_despawn(int p_peer_id, const ResourceUI
 	} else if (data_size) {
 		encode_variant(p_data, &ptr[SPAWN_CMD_OFFSET], data_size);
 	}
-	Ref<MultiplayerPeer> network_peer = multiplayer->get_network_peer();
-	network_peer->set_target_peer(p_peer_id);
-	network_peer->set_transfer_channel(0);
-	network_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
-	return network_peer->put_packet(ptr, SPAWN_CMD_OFFSET + data_size);
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	peer->set_target_peer(p_peer_id);
+	peer->set_transfer_channel(0);
+	peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
+	return peer->put_packet(ptr, SPAWN_CMD_OFFSET + data_size);
 }
 
 Error MultiplayerReplicator::send_despawn(int p_peer_id, const ResourceUID::ID &p_scene_id, const Variant &p_data, const NodePath &p_path) {
-	ERR_FAIL_COND_V(!multiplayer->has_network_peer(), ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!multiplayer->has_multiplayer_peer(), ERR_UNCONFIGURED);
 	ERR_FAIL_COND_V_MSG(!replications.has(p_scene_id), ERR_INVALID_PARAMETER, vformat("Spawnable not found: %d", p_scene_id));
 	const SceneConfig &cfg = replications[p_scene_id];
 	if (cfg.on_spawn_despawn_send.is_valid()) {
 		return _send_spawn_despawn(p_peer_id, p_scene_id, p_data, true);
 	} else {
-		ERR_FAIL_COND_V_MSG(cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_network_server(), ERR_UNAVAILABLE, "Manual despawn is restricted in default server mode implementation. Use custom mode if you desire control over server spawn requests.");
+		ERR_FAIL_COND_V_MSG(cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_server(), ERR_UNAVAILABLE, "Manual despawn is restricted in default server mode implementation. Use custom mode if you desire control over server spawn requests.");
 		NodePath path = p_path;
 		Object *obj = p_data.get_type() == Variant::OBJECT ? p_data.get_validated_object() : nullptr;
 		if (path.is_empty() && obj) {
@@ -542,13 +542,13 @@ Error MultiplayerReplicator::send_despawn(int p_peer_id, const ResourceUID::ID &
 }
 
 Error MultiplayerReplicator::send_spawn(int p_peer_id, const ResourceUID::ID &p_scene_id, const Variant &p_data, const NodePath &p_path) {
-	ERR_FAIL_COND_V(!multiplayer->has_network_peer(), ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!multiplayer->has_multiplayer_peer(), ERR_UNCONFIGURED);
 	ERR_FAIL_COND_V_MSG(!replications.has(p_scene_id), ERR_INVALID_PARAMETER, vformat("Spawnable not found: %d", p_scene_id));
 	const SceneConfig &cfg = replications[p_scene_id];
 	if (cfg.on_spawn_despawn_send.is_valid()) {
 		return _send_spawn_despawn(p_peer_id, p_scene_id, p_data, false);
 	} else {
-		ERR_FAIL_COND_V_MSG(cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_network_server(), ERR_UNAVAILABLE, "Manual spawn is restricted in default server mode implementation. Use custom mode if you desire control over server spawn requests.");
+		ERR_FAIL_COND_V_MSG(cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_server(), ERR_UNAVAILABLE, "Manual spawn is restricted in default server mode implementation. Use custom mode if you desire control over server spawn requests.");
 		NodePath path = p_path;
 		Object *obj = p_data.get_type() == Variant::OBJECT ? p_data.get_validated_object() : nullptr;
 		ERR_FAIL_COND_V_MSG(!obj, ERR_INVALID_PARAMETER, "Spawn default implementation requires the data to be an object.");
@@ -619,7 +619,7 @@ Error MultiplayerReplicator::decode_state(const ResourceUID::ID &p_scene_id, Obj
 }
 
 void MultiplayerReplicator::scene_enter_exit_notify(const String &p_scene, Node *p_node, bool p_enter) {
-	if (!multiplayer->has_network_peer()) {
+	if (!multiplayer->has_multiplayer_peer()) {
 		return;
 	}
 	Node *root_node = multiplayer->get_root_node();
@@ -634,14 +634,14 @@ void MultiplayerReplicator::scene_enter_exit_notify(const String &p_scene, Node
 	}
 	const SceneConfig &cfg = replications[id];
 	if (p_enter) {
-		if (cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_network_server()) {
+		if (cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_server()) {
 			replicated_nodes[p_node->get_instance_id()] = id;
 			_track(id, p_node);
 			spawn(id, p_node, 0);
 		}
 		emit_signal(SNAME("replicated_instance_added"), id, p_node);
 	} else {
-		if (cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_network_server() && replicated_nodes.has(p_node->get_instance_id())) {
+		if (cfg.mode == REPLICATION_MODE_SERVER && multiplayer->is_server() && replicated_nodes.has(p_node->get_instance_id())) {
 			replicated_nodes.erase(p_node->get_instance_id());
 			_untrack(id, p_node);
 			despawn(id, p_node, 0);
@@ -666,7 +666,7 @@ void MultiplayerReplicator::poll() {
 		if (!E.value.sync_interval) {
 			continue;
 		}
-		if (E.value.mode == REPLICATION_MODE_SERVER && !multiplayer->is_network_server()) {
+		if (E.value.mode == REPLICATION_MODE_SERVER && !multiplayer->is_server()) {
 			continue;
 		}
 		uint64_t time = OS::get_singleton()->get_ticks_usec();
@@ -741,7 +741,7 @@ Error MultiplayerReplicator::sync_all(const ResourceUID::ID &p_scene_id, int p_p
 }
 
 Error MultiplayerReplicator::send_sync(int p_peer_id, const ResourceUID::ID &p_scene_id, PackedByteArray p_data, Multiplayer::TransferMode p_transfer_mode, int p_channel) {
-	ERR_FAIL_COND_V(!multiplayer->has_network_peer(), ERR_UNCONFIGURED);
+	ERR_FAIL_COND_V(!multiplayer->has_multiplayer_peer(), ERR_UNCONFIGURED);
 	ERR_FAIL_COND_V(!replications.has(p_scene_id), ERR_INVALID_PARAMETER);
 	const SceneConfig &cfg = replications[p_scene_id];
 	ERR_FAIL_COND_V_MSG(!cfg.on_sync_send.is_valid(), ERR_UNCONFIGURED, "Sending raw sync messages is only available with custom functions");
@@ -749,11 +749,11 @@ Error MultiplayerReplicator::send_sync(int p_peer_id, const ResourceUID::ID &p_s
 	uint8_t *ptr = packet_cache.ptrw();
 	ptr[0] = MultiplayerAPI::NETWORK_COMMAND_SYNC;
 	encode_uint64(p_scene_id, &ptr[1]);
-	Ref<MultiplayerPeer> network_peer = multiplayer->get_network_peer();
-	network_peer->set_target_peer(p_peer_id);
-	network_peer->set_transfer_channel(p_channel);
-	network_peer->set_transfer_mode(p_transfer_mode);
-	return network_peer->put_packet(ptr, SYNC_CMD_OFFSET + p_data.size());
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	peer->set_target_peer(p_peer_id);
+	peer->set_transfer_channel(p_channel);
+	peer->set_transfer_mode(p_transfer_mode);
+	return peer->put_packet(ptr, SYNC_CMD_OFFSET + p_data.size());
 }
 
 void MultiplayerReplicator::clear() {
diff --git a/core/multiplayer/rpc_manager.cpp b/core/multiplayer/rpc_manager.cpp
index 135dc4a187..915571375e 100644
--- a/core/multiplayer/rpc_manager.cpp
+++ b/core/multiplayer/rpc_manager.cpp
@@ -103,7 +103,7 @@ _FORCE_INLINE_ bool _can_call_mode(Node *p_node, Multiplayer::RPCMode mode, int
 			return true;
 		} break;
 		case Multiplayer::RPC_MODE_AUTHORITY: {
-			return !p_node->is_network_authority() && p_remote_id == p_node->get_network_authority();
+			return !p_node->is_multiplayer_authority() && p_remote_id == p_node->get_multiplayer_authority();
 		} break;
 	}
 
@@ -232,7 +232,7 @@ void RPCManager::_process_rpc(Node *p_node, const uint16_t p_rpc_method_id, int
 	ERR_FAIL_COND(config.name == StringName());
 
 	bool can_call = _can_call_mode(p_node, config.rpc_mode, p_from);
-	ERR_FAIL_COND_MSG(!can_call, "RPC '" + String(config.name) + "' is not allowed on node " + p_node->get_path() + " from: " + itos(p_from) + ". Mode is " + itos((int)config.rpc_mode) + ", authority is " + itos(p_node->get_network_authority()) + ".");
+	ERR_FAIL_COND_MSG(!can_call, "RPC '" + String(config.name) + "' is not allowed on node " + p_node->get_path() + " from: " + itos(p_from) + ". Mode is " + itos((int)config.rpc_mode) + ", authority is " + itos(p_node->get_multiplayer_authority()) + ".");
 
 	int argc = 0;
 	bool byte_only = false;
@@ -294,19 +294,19 @@ void RPCManager::_process_rpc(Node *p_node, const uint16_t p_rpc_method_id, int
 }
 
 void RPCManager::_send_rpc(Node *p_from, int p_to, uint16_t p_rpc_id, const Multiplayer::RPCConfig &p_config, const StringName &p_name, const Variant **p_arg, int p_argcount) {
-	Ref<MultiplayerPeer> network_peer = multiplayer->get_network_peer();
-	ERR_FAIL_COND_MSG(network_peer.is_null(), "Attempt to remote call/set when networking is not active in SceneTree.");
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	ERR_FAIL_COND_MSG(peer.is_null(), "Attempt to call RPC without active multiplayer peer.");
 
-	ERR_FAIL_COND_MSG(network_peer->get_connection_status() == MultiplayerPeer::CONNECTION_CONNECTING, "Attempt to remote call/set when networking is not connected yet in SceneTree.");
+	ERR_FAIL_COND_MSG(peer->get_connection_status() == MultiplayerPeer::CONNECTION_CONNECTING, "Attempt to call RPC while multiplayer peer is not connected yet.");
 
-	ERR_FAIL_COND_MSG(network_peer->get_connection_status() == MultiplayerPeer::CONNECTION_DISCONNECTED, "Attempt to remote call/set when networking is disconnected.");
+	ERR_FAIL_COND_MSG(peer->get_connection_status() == MultiplayerPeer::CONNECTION_DISCONNECTED, "Attempt to call RPC while multiplayer peer is disconnected.");
 
-	ERR_FAIL_COND_MSG(p_argcount > 255, "Too many arguments >255.");
+	ERR_FAIL_COND_MSG(p_argcount > 255, "Too many arguments (>255).");
 
-	if (p_to != 0 && !multiplayer->get_network_connected_peers().has(ABS(p_to))) {
-		ERR_FAIL_COND_MSG(p_to == network_peer->get_unique_id(), "Attempt to remote call/set yourself! unique ID: " + itos(network_peer->get_unique_id()) + ".");
+	if (p_to != 0 && !multiplayer->get_connected_peers().has(ABS(p_to))) {
+		ERR_FAIL_COND_MSG(p_to == peer->get_unique_id(), "Attempt to call RPC on yourself! Peer unique ID: " + itos(peer->get_unique_id()) + ".");
 
-		ERR_FAIL_MSG("Attempt to remote call unexisting ID: " + itos(p_to) + ".");
+		ERR_FAIL_MSG("Attempt to call RPC with unknown peer ID: " + itos(p_to) + ".");
 	}
 
 	NodePath from_path = (multiplayer->get_root_node()->get_path()).rel_path_to(p_from->get_path());
@@ -416,13 +416,13 @@ void RPCManager::_send_rpc(Node *p_from, int p_to, uint16_t p_rpc_id, const Mult
 #endif
 
 	// Take chance and set transfer mode, since all send methods will use it.
-	network_peer->set_transfer_channel(p_config.channel);
-	network_peer->set_transfer_mode(p_config.transfer_mode);
+	peer->set_transfer_channel(p_config.channel);
+	peer->set_transfer_mode(p_config.transfer_mode);
 
 	if (has_all_peers) {
 		// They all have verified paths, so send fast.
-		network_peer->set_target_peer(p_to); // To all of you.
-		network_peer->put_packet(packet_cache.ptr(), ofs); // A message with love.
+		peer->set_target_peer(p_to); // To all of you.
+		peer->put_packet(packet_cache.ptr(), ofs); // A message with love.
 	} else {
 		// Unreachable because the node ID is never compressed if the peers doesn't know it.
 		CRASH_COND(node_id_compression != NETWORK_NODE_ID_COMPRESSION_32);
@@ -446,28 +446,28 @@ void RPCManager::_send_rpc(Node *p_from, int p_to, uint16_t p_rpc_id, const Mult
 
 			bool confirmed = multiplayer->is_cache_confirmed(from_path, P);
 
-			network_peer->set_target_peer(P); // To this one specifically.
+			peer->set_target_peer(P); // To this one specifically.
 
 			if (confirmed) {
 				// This one confirmed path, so use id.
 				encode_uint32(psc_id, &(packet_cache.write[1]));
-				network_peer->put_packet(packet_cache.ptr(), ofs);
+				peer->put_packet(packet_cache.ptr(), ofs);
 			} else {
 				// This one did not confirm path yet, so use entire path (sorry!).
 				encode_uint32(0x80000000 | ofs, &(packet_cache.write[1])); // Offset to path and flag.
-				network_peer->put_packet(packet_cache.ptr(), ofs + path_len);
+				peer->put_packet(packet_cache.ptr(), ofs + path_len);
 			}
 		}
 	}
 }
 
 void RPCManager::rpcp(Node *p_node, int p_peer_id, const StringName &p_method, const Variant **p_arg, int p_argcount) {
-	Ref<MultiplayerPeer> network_peer = multiplayer->get_network_peer();
-	ERR_FAIL_COND_MSG(!network_peer.is_valid(), "Trying to call an RPC while no network peer is active.");
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	ERR_FAIL_COND_MSG(!peer.is_valid(), "Trying to call an RPC while no multiplayer peer is active.");
 	ERR_FAIL_COND_MSG(!p_node->is_inside_tree(), "Trying to call an RPC on a node which is not inside SceneTree.");
-	ERR_FAIL_COND_MSG(network_peer->get_connection_status() != MultiplayerPeer::CONNECTION_CONNECTED, "Trying to call an RPC via a network peer which is not connected.");
+	ERR_FAIL_COND_MSG(peer->get_connection_status() != MultiplayerPeer::CONNECTION_CONNECTED, "Trying to call an RPC via a multiplayer peer which is not connected.");
 
-	int node_id = network_peer->get_unique_id();
+	int node_id = peer->get_unique_id();
 	bool call_local_native = false;
 	bool call_local_script = false;
 	uint16_t rpc_id = UINT16_MAX;
@@ -493,7 +493,7 @@ void RPCManager::rpcp(Node *p_node, int p_peer_id, const StringName &p_method, c
 	if (call_local_native) {
 		Callable::CallError ce;
 
-		multiplayer->set_remote_sender_override(network_peer->get_unique_id());
+		multiplayer->set_remote_sender_override(peer->get_unique_id());
 		p_node->call(p_method, p_arg, p_argcount, ce);
 		multiplayer->set_remote_sender_override(0);
 
@@ -509,7 +509,7 @@ void RPCManager::rpcp(Node *p_node, int p_peer_id, const StringName &p_method, c
 		Callable::CallError ce;
 		ce.error = Callable::CallError::CALL_OK;
 
-		multiplayer->set_remote_sender_override(network_peer->get_unique_id());
+		multiplayer->set_remote_sender_override(peer->get_unique_id());
 		p_node->get_script_instance()->call(p_method, p_arg, p_argcount, ce);
 		multiplayer->set_remote_sender_override(0);