Nixyri/godot
1
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-11-22 04:06:14 +00:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

[Net] MultiplayerPeer cleanup, defaults.

Browse Source
This commit is contained in:
Fabio Alessandrelli 2021-09-07 23:04:52 +02:00
parent 7c81ce43ec
commit 25226329be
8 changed files with 68 additions and 139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
core/multiplayer/multiplayer_peer.cpp
View File

@ -53,6 +53,30 @@ uint32_t MultiplayerPeer::generate_unique_id() const {
return hash;
}
void MultiplayerPeer::set_transfer_channel(int p_channel) {
transfer_channel = p_channel;
}
int MultiplayerPeer::get_transfer_channel() const {
return transfer_channel;
}
void MultiplayerPeer::set_transfer_mode(Multiplayer::TransferMode p_mode) {
transfer_mode = p_mode;
}
Multiplayer::TransferMode MultiplayerPeer::get_transfer_mode() const {
return transfer_mode;
}
void MultiplayerPeer::set_refuse_new_connections(bool p_enable) {
refuse_connections = p_enable;
}
bool MultiplayerPeer::is_refusing_new_connections() const {
return refuse_connections;
}
void MultiplayerPeer::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_transfer_channel", "channel"), &MultiplayerPeer::set_transfer_channel);
ClassDB::bind_method(D_METHOD("get_transfer_channel"), &MultiplayerPeer::get_transfer_channel);
@ -131,7 +155,7 @@ void MultiplayerPeerExtension::set_transfer_channel(int p_channel) {
if (GDVIRTUAL_CALL(_set_transfer_channel, p_channel)) {
return;
}
WARN_PRINT_ONCE("MultiplayerPeerExtension::_set_transfer_channel is unimplemented!");
MultiplayerPeer::set_transfer_channel(p_channel);
}
int MultiplayerPeerExtension::get_transfer_channel() const {
@ -139,15 +163,14 @@ int MultiplayerPeerExtension::get_transfer_channel() const {
if (GDVIRTUAL_CALL(_get_transfer_channel, channel)) {
return channel;
}
WARN_PRINT_ONCE("MultiplayerPeerExtension::_get_transfer_channel is unimplemented!");
return 0;
return MultiplayerPeer::get_transfer_channel();
}
void MultiplayerPeerExtension::set_transfer_mode(Multiplayer::TransferMode p_mode) {
if (GDVIRTUAL_CALL(_set_transfer_mode, p_mode)) {
return;
}
WARN_PRINT_ONCE("MultiplayerPeerExtension::_set_transfer_mode is unimplemented!");
MultiplayerPeer::set_transfer_mode(p_mode);
}
Multiplayer::TransferMode MultiplayerPeerExtension::get_transfer_mode() const {
@ -155,8 +178,7 @@ Multiplayer::TransferMode MultiplayerPeerExtension::get_transfer_mode() const {
if (GDVIRTUAL_CALL(_get_transfer_mode, mode)) {
return (Multiplayer::TransferMode)mode;
}
WARN_PRINT_ONCE("MultiplayerPeerExtension::_get_transfer_mode is unimplemented!");
return Multiplayer::TRANSFER_MODE_UNRELIABLE;
return MultiplayerPeer::get_transfer_mode();
}
void MultiplayerPeerExtension::set_target_peer(int p_peer_id) {
@ -205,7 +227,7 @@ void MultiplayerPeerExtension::set_refuse_new_connections(bool p_enable) {
if (GDVIRTUAL_CALL(_set_refuse_new_connections, p_enable)) {
return;
}
WARN_PRINT_ONCE("MultiplayerPeerExtension::_set_refuse_new_connections is unimplemented!");
MultiplayerPeer::set_refuse_new_connections(p_enable);
}
bool MultiplayerPeerExtension::is_refusing_new_connections() const {
@ -213,8 +235,7 @@ bool MultiplayerPeerExtension::is_refusing_new_connections() const {
if (GDVIRTUAL_CALL(_is_refusing_new_connections, refusing)) {
return refusing;
}
WARN_PRINT_ONCE("MultiplayerPeerExtension::_is_refusing_new_connections is unimplemented!");
return false;
return MultiplayerPeer::is_refusing_new_connections();
}
MultiplayerPeer::ConnectionStatus MultiplayerPeerExtension::get_connection_status() const {

19
core/multiplayer/multiplayer_peer.h
View File

@ -44,6 +44,11 @@ class MultiplayerPeer : public PacketPeer {
protected:
static void _bind_methods();
private:
int transfer_channel = 0;
Multiplayer::TransferMode transfer_mode = Multiplayer::TRANSFER_MODE_RELIABLE;
bool refuse_connections = false;
public:
enum {
TARGET_PEER_BROADCAST = 0,
@ -56,10 +61,13 @@ public:
CONNECTION_CONNECTED,
};
virtual void set_transfer_channel(int p_channel) = 0;
virtual int get_transfer_channel() const = 0;
virtual void set_transfer_mode(Multiplayer::TransferMode p_mode) = 0;
virtual Multiplayer::TransferMode get_transfer_mode() const = 0;
virtual void set_transfer_channel(int p_channel);
virtual int get_transfer_channel() const;
virtual void set_transfer_mode(Multiplayer::TransferMode p_mode);
virtual Multiplayer::TransferMode get_transfer_mode() const;
virtual void set_refuse_new_connections(bool p_enable);
virtual bool is_refusing_new_connections() const;
virtual void set_target_peer(int p_peer_id) = 0;
virtual int get_packet_peer() const = 0;
@ -70,9 +78,6 @@ public:
virtual int get_unique_id() const = 0;
virtual void set_refuse_new_connections(bool p_enable) = 0;
virtual bool is_refusing_new_connections() const = 0;
virtual ConnectionStatus get_connection_status() const = 0;
uint32_t generate_unique_id() const;

37
modules/enet/enet_multiplayer_peer.cpp
View File

@ -33,22 +33,6 @@
#include "core/io/marshalls.h"
#include "core/os/os.h"
void ENetMultiplayerPeer::set_transfer_channel(int p_channel) {
transfer_channel = p_channel;
}
int ENetMultiplayerPeer::get_transfer_channel() const {
return transfer_channel;
}
void ENetMultiplayerPeer::set_transfer_mode(Multiplayer::TransferMode p_mode) {
transfer_mode = p_mode;
}
Multiplayer::TransferMode ENetMultiplayerPeer::get_transfer_mode() const {
return transfer_mode;
}
void ENetMultiplayerPeer::set_target_peer(int p_peer) {
target_peer = p_peer;
}
@ -62,6 +46,7 @@ int ENetMultiplayerPeer::get_packet_peer() const {
Error ENetMultiplayerPeer::create_server(int p_port, int p_max_clients, int p_max_channels, int p_in_bandwidth, int p_out_bandwidth) {
ERR_FAIL_COND_V_MSG(_is_active(), ERR_ALREADY_IN_USE, "The multiplayer instance is already active.");
set_refuse_new_connections(false);
Ref<ENetConnection> host;
host.instantiate();
Error err = host->create_host_bound(bind_ip, p_port, p_max_clients, 0, p_max_channels > 0 ? p_max_channels + SYSCH_MAX : 0, p_out_bandwidth);
@ -70,7 +55,6 @@ Error ENetMultiplayerPeer::create_server(int p_port, int p_max_clients, int p_ma
}
active_mode = MODE_SERVER;
refuse_connections = false;
unique_id = 1;
connection_status = CONNECTION_CONNECTED;
hosts[0] = host;
@ -79,6 +63,7 @@ Error ENetMultiplayerPeer::create_server(int p_port, int p_max_clients, int p_ma
Error ENetMultiplayerPeer::create_client(const String &p_address, int p_port, int p_channel_count, int p_in_bandwidth, int p_out_bandwidth, int p_local_port) {
ERR_FAIL_COND_V_MSG(_is_active(), ERR_ALREADY_IN_USE, "The multiplayer instance is already active.");
set_refuse_new_connections(false);
Ref<ENetConnection> host;
host.instantiate();
Error err;
@ -102,7 +87,6 @@ Error ENetMultiplayerPeer::create_client(const String &p_address, int p_port, in
// Need to wait for CONNECT event.
connection_status = CONNECTION_CONNECTING;
active_mode = MODE_CLIENT;
refuse_connections = false;
peers[1] = peer;
hosts[0] = host;
@ -113,7 +97,6 @@ Error ENetMultiplayerPeer::create_mesh(int p_id) {
ERR_FAIL_COND_V_MSG(p_id <= 0, ERR_INVALID_PARAMETER, "The unique ID must be greater then 0");
ERR_FAIL_COND_V_MSG(_is_active(), ERR_ALREADY_IN_USE, "The multiplayer instance is already active.");
active_mode = MODE_MESH;
refuse_connections = false;
unique_id = p_id;
connection_status = CONNECTION_CONNECTED;
return OK;
@ -145,7 +128,7 @@ bool ENetMultiplayerPeer::_poll_server() {
}
switch (ret) {
case ENetConnection::EVENT_CONNECT: {
if (refuse_connections) {
if (is_refusing_new_connections()) {
event.peer->reset();
return false;
}
@ -423,6 +406,7 @@ void ENetMultiplayerPeer::close_connection(uint32_t wait_usec) {
hosts.clear();
unique_id = 0;
connection_status = CONNECTION_DISCONNECTED;
set_refuse_new_connections(false);
}
int ENetMultiplayerPeer::get_available_packet_count() const {
@ -451,10 +435,11 @@ Error ENetMultiplayerPeer::put_packet(const uint8_t *p_buffer, int p_buffer_size
int packet_flags = 0;
int channel = SYSCH_RELIABLE;
int transfer_channel = get_transfer_channel();
if (transfer_channel > 0) {
channel = SYSCH_MAX + transfer_channel - 1;
} else {
switch (transfer_mode) {
switch (get_transfer_mode()) {
case Multiplayer::TRANSFER_MODE_UNRELIABLE: {
packet_flags = ENET_PACKET_FLAG_UNSEQUENCED;
channel = SYSCH_UNRELIABLE;
@ -545,19 +530,15 @@ int ENetMultiplayerPeer::get_unique_id() const {
return unique_id;
}
void ENetMultiplayerPeer::set_refuse_new_connections(bool p_enable) {
refuse_connections = p_enable;
void ENetMultiplayerPeer::set_refuse_new_connections(bool p_enabled) {
#ifdef GODOT_ENET
if (_is_active()) {
for (KeyValue<int, Ref<ENetConnection>> &E : hosts) {
E.value->refuse_new_connections(p_enable);
E.value->refuse_new_connections(p_enabled);
}
}
#endif
}
bool ENetMultiplayerPeer::is_refusing_new_connections() const {
return refuse_connections;
MultiplayerPeer::set_refuse_new_connections(p_enabled);
}
void ENetMultiplayerPeer::set_server_relay_enabled(bool p_enabled) {

40
modules/enet/enet_multiplayer_peer.h
View File

@ -65,10 +65,7 @@ private:
uint32_t unique_id = 0;
int target_peer = 0;
int transfer_channel = 0;
Multiplayer::TransferMode transfer_mode = Multiplayer::TRANSFER_MODE_RELIABLE;
bool refuse_connections = false;
bool server_relay = true;
ConnectionStatus connection_status = CONNECTION_DISCONNECTED;
@ -101,15 +98,23 @@ protected:
static void _bind_methods();
public:
virtual void set_transfer_channel(int p_channel) override;
virtual int get_transfer_channel() const override;
virtual void set_transfer_mode(Multiplayer::TransferMode p_mode) override;
virtual Multiplayer::TransferMode get_transfer_mode() const override;
virtual void set_target_peer(int p_peer) override;
virtual int get_packet_peer() const override;
virtual void poll() override;
virtual bool is_server() const override;
// Overriden so we can instrument the DTLSServer when needed.
virtual void set_refuse_new_connections(bool p_enabled) override;
virtual ConnectionStatus get_connection_status() const override;
virtual int get_unique_id() const override;
virtual int get_max_packet_size() const override;
virtual int get_available_packet_count() const override;
virtual Error get_packet(const uint8_t **r_buffer, int &r_buffer_size) override;
virtual Error put_packet(const uint8_t *p_buffer, int p_buffer_size) override;
Error create_server(int p_port, int p_max_clients = 32, int p_max_channels = 0, int p_in_bandwidth = 0, int p_out_bandwidth = 0);
Error create_client(const String &p_address, int p_port, int p_channel_count = 0, int p_in_bandwidth = 0, int p_out_bandwidth = 0, int p_local_port = 0);
Error create_mesh(int p_id);
@ -119,23 +124,6 @@ public:
void disconnect_peer(int p_peer, bool now = false);
virtual void poll() override;
virtual bool is_server() const override;
virtual int get_available_packet_count() const override;
virtual Error get_packet(const uint8_t **r_buffer, int &r_buffer_size) override; ///< buffer is GONE after next get_packet
virtual Error put_packet(const uint8_t *p_buffer, int p_buffer_size) override;
virtual int get_max_packet_size() const override;
virtual ConnectionStatus get_connection_status() const override;
virtual void set_refuse_new_connections(bool p_enable) override;
virtual bool is_refusing_new_connections() const override;
virtual int get_unique_id() const override;
void set_bind_ip(const IPAddress &p_ip);
void set_server_relay_enabled(bool p_enabled);
bool is_server_relay_enabled() const;

30
modules/webrtc/webrtc_multiplayer_peer.cpp
View File

@ -43,22 +43,6 @@ void WebRTCMultiplayerPeer::_bind_methods() {
ClassDB::bind_method(D_METHOD("close"), &WebRTCMultiplayerPeer::close);
}
void WebRTCMultiplayerPeer::set_transfer_channel(int p_channel) {
transfer_channel = p_channel;
}
int WebRTCMultiplayerPeer::get_transfer_channel() const {
return transfer_channel;
}
void WebRTCMultiplayerPeer::set_transfer_mode(Multiplayer::TransferMode p_mode) {
transfer_mode = p_mode;
}
Multiplayer::TransferMode WebRTCMultiplayerPeer::get_transfer_mode() const {
return transfer_mode;
}
void WebRTCMultiplayerPeer::set_target_peer(int p_peer_id) {
target_peer = p_peer_id;
}
@ -188,14 +172,6 @@ void WebRTCMultiplayerPeer::_find_next_peer() {
next_packet_peer = 0;
}
void WebRTCMultiplayerPeer::set_refuse_new_connections(bool p_enable) {
refuse_connections = p_enable;
}
bool WebRTCMultiplayerPeer::is_refusing_new_connections() const {
return refuse_connections;
}
MultiplayerPeer::ConnectionStatus WebRTCMultiplayerPeer::get_connection_status() const {
return connection_status;
}
@ -279,7 +255,7 @@ Dictionary WebRTCMultiplayerPeer::get_peers() {
Error WebRTCMultiplayerPeer::add_peer(Ref<WebRTCPeerConnection> p_peer, int p_peer_id, int p_unreliable_lifetime) {
ERR_FAIL_COND_V(p_peer_id < 0 || p_peer_id > ~(1 << 31), ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(p_unreliable_lifetime < 0, ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(refuse_connections, ERR_UNAUTHORIZED);
ERR_FAIL_COND_V(is_refusing_new_connections(), ERR_UNAUTHORIZED);
// Peer must be valid, and in new state (to create data channels)
ERR_FAIL_COND_V(!p_peer.is_valid(), ERR_INVALID_PARAMETER);
ERR_FAIL_COND_V(p_peer->get_connection_state() != WebRTCPeerConnection::STATE_NEW, ERR_INVALID_PARAMETER);
@ -352,9 +328,9 @@ Error WebRTCMultiplayerPeer::get_packet(const uint8_t **r_buffer, int &r_buffer_
Error WebRTCMultiplayerPeer::put_packet(const uint8_t *p_buffer, int p_buffer_size) {
ERR_FAIL_COND_V(connection_status == CONNECTION_DISCONNECTED, ERR_UNCONFIGURED);
int ch = transfer_channel;
int ch = get_transfer_channel();
if (ch == 0) {
switch (transfer_mode) {
switch (get_transfer_mode()) {
case Multiplayer::TRANSFER_MODE_RELIABLE:
ch = CH_RELIABLE;
break;

10
modules/webrtc/webrtc_multiplayer_peer.h
View File

@ -65,10 +65,7 @@ private:
uint32_t unique_id = 0;
int target_peer = 0;
int client_count = 0;
bool refuse_connections = false;
ConnectionStatus connection_status = CONNECTION_DISCONNECTED;
int transfer_channel = 0;
Multiplayer::TransferMode transfer_mode = Multiplayer::TRANSFER_MODE_RELIABLE;
int next_packet_peer = 0;
bool server_compat = false;
@ -97,10 +94,6 @@ public:
int get_max_packet_size() const override;
// MultiplayerPeer
void set_transfer_channel(int p_channel) override;
int get_transfer_channel() const override;
void set_transfer_mode(Multiplayer::TransferMode p_mode) override;
Multiplayer::TransferMode get_transfer_mode() const override;
void set_target_peer(int p_peer_id) override;
int get_unique_id() const override;
@ -110,9 +103,6 @@ public:
void poll() override;
void set_refuse_new_connections(bool p_enable) override;
bool is_refusing_new_connections() const override;
ConnectionStatus get_connection_status() const override;
};

25
modules/websocket/websocket_multiplayer_peer.cpp
View File

@ -105,23 +105,6 @@ Error WebSocketMultiplayerPeer::put_packet(const uint8_t *p_buffer, int p_buffer
//
// MultiplayerPeer
//
void WebSocketMultiplayerPeer::set_transfer_channel(int p_channel) {
// Websocket does not have channels.
}
int WebSocketMultiplayerPeer::get_transfer_channel() const {
return 0;
}
void WebSocketMultiplayerPeer::set_transfer_mode(Multiplayer::TransferMode p_mode) {
// Websocket uses TCP, reliable
}
Multiplayer::TransferMode WebSocketMultiplayerPeer::get_transfer_mode() const {
// Websocket uses TCP, reliable
return Multiplayer::TRANSFER_MODE_RELIABLE;
}
void WebSocketMultiplayerPeer::set_target_peer(int p_target_peer) {
_target_peer = p_target_peer;
}
@ -137,14 +120,6 @@ int WebSocketMultiplayerPeer::get_unique_id() const {
return _peer_id;
}
void WebSocketMultiplayerPeer::set_refuse_new_connections(bool p_enable) {
_refusing = p_enable;
}
bool WebSocketMultiplayerPeer::is_refusing_new_connections() const {
return _refusing;
}
void WebSocketMultiplayerPeer::_send_sys(Ref<WebSocketPeer> p_peer, uint8_t p_type, int32_t p_peer_id) {
ERR_FAIL_COND(!p_peer.is_valid());
ERR_FAIL_COND(!p_peer->is_connected_to_host());

7
modules/websocket/websocket_multiplayer_peer.h
View File

@ -68,7 +68,6 @@ protected:
bool _is_multiplayer = false;
int _target_peer = 0;
int _peer_id = 0;
int _refusing = false;
static void _bind_methods();
@ -78,15 +77,9 @@ protected:
public:
/* MultiplayerPeer */
void set_transfer_channel(int p_channel) override;
int get_transfer_channel() const override;
void set_transfer_mode(Multiplayer::TransferMode p_mode) override;
Multiplayer::TransferMode get_transfer_mode() const override;
void set_target_peer(int p_target_peer) override;
int get_packet_peer() const override;
int get_unique_id() const override;
void set_refuse_new_connections(bool p_enable) override;
bool is_refusing_new_connections() const override;
/* PacketPeer */
virtual int get_available_packet_count() const override;