mirror of
https://github.com/godotengine/godot
synced 2024-10-04 17:57:11 +00:00
373d5ea103
It used to call `enet_host_service` until all events were consumed, but that also meant constantly polling the connection leading to potentially unbounded processing time. It now only service the connection once, and instead consumes all the retrieved events via `enet_host_check_events`.
678 lines
22 KiB
C++
678 lines
22 KiB
C++
/*************************************************************************/
|
|
/* enet_multiplayer_peer.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
|
|
/* */
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
/* a copy of this software and associated documentation files (the */
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
/* the following conditions: */
|
|
/* */
|
|
/* The above copyright notice and this permission notice shall be */
|
|
/* included in all copies or substantial portions of the Software. */
|
|
/* */
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
/*************************************************************************/
|
|
|
|
#include "enet_multiplayer_peer.h"
|
|
#include "core/io/ip.h"
|
|
#include "core/io/marshalls.h"
|
|
#include "core/os/os.h"
|
|
|
|
void ENetMultiplayerPeer::set_target_peer(int p_peer) {
|
|
target_peer = p_peer;
|
|
}
|
|
|
|
int ENetMultiplayerPeer::get_packet_peer() const {
|
|
ERR_FAIL_COND_V_MSG(!_is_active(), 1, "The multiplayer instance isn't currently active.");
|
|
ERR_FAIL_COND_V(incoming_packets.size() == 0, 1);
|
|
|
|
return incoming_packets.front()->get().from;
|
|
}
|
|
|
|
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);
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
active_mode = MODE_SERVER;
|
|
unique_id = 1;
|
|
connection_status = CONNECTION_CONNECTED;
|
|
hosts[0] = host;
|
|
return OK;
|
|
}
|
|
|
|
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;
|
|
if (p_local_port) {
|
|
err = host->create_host_bound(bind_ip, p_local_port, 1, 0, p_in_bandwidth, p_out_bandwidth);
|
|
} else {
|
|
err = host->create_host(1, 0, p_in_bandwidth, p_out_bandwidth);
|
|
}
|
|
if (err != OK) {
|
|
return err;
|
|
}
|
|
|
|
unique_id = generate_unique_id();
|
|
|
|
Ref<ENetPacketPeer> peer = host->connect_to_host(p_address, p_port, p_channel_count > 0 ? p_channel_count + SYSCH_MAX : 0, unique_id);
|
|
if (peer.is_null()) {
|
|
host->destroy();
|
|
ERR_FAIL_V_MSG(ERR_CANT_CREATE, "Couldn't connect to the ENet multiplayer server.");
|
|
}
|
|
|
|
// Need to wait for CONNECT event.
|
|
connection_status = CONNECTION_CONNECTING;
|
|
active_mode = MODE_CLIENT;
|
|
peers[1] = peer;
|
|
hosts[0] = host;
|
|
|
|
return OK;
|
|
}
|
|
|
|
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;
|
|
unique_id = p_id;
|
|
connection_status = CONNECTION_CONNECTED;
|
|
return OK;
|
|
}
|
|
|
|
Error ENetMultiplayerPeer::add_mesh_peer(int p_id, Ref<ENetConnection> p_host) {
|
|
ERR_FAIL_COND_V(p_host.is_null(), ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V_MSG(active_mode != MODE_MESH, ERR_UNCONFIGURED, "The multiplayer instance is not configured as a mesh. Call 'create_mesh' first.");
|
|
List<Ref<ENetPacketPeer>> host_peers;
|
|
p_host->get_peers(host_peers);
|
|
ERR_FAIL_COND_V_MSG(host_peers.size() != 1 || host_peers[0]->get_state() != ENetPacketPeer::STATE_CONNECTED, ERR_INVALID_PARAMETER, "The provided host must have excatly one peer in the connected state.");
|
|
hosts[p_id] = p_host;
|
|
peers[p_id] = host_peers[0];
|
|
emit_signal(SNAME("peer_connected"), p_id);
|
|
return OK;
|
|
}
|
|
|
|
bool ENetMultiplayerPeer::_parse_server_event(ENetConnection::EventType p_type, ENetConnection::Event &p_event) {
|
|
switch (p_type) {
|
|
case ENetConnection::EVENT_CONNECT: {
|
|
if (is_refusing_new_connections()) {
|
|
p_event.peer->reset();
|
|
return false;
|
|
}
|
|
// Client joined with invalid ID, probably trying to exploit us.
|
|
if (p_event.data < 2 || peers.has((int)p_event.data)) {
|
|
p_event.peer->reset();
|
|
return false;
|
|
}
|
|
int id = p_event.data;
|
|
p_event.peer->set_meta(SNAME("_net_id"), id);
|
|
peers[id] = p_event.peer;
|
|
|
|
emit_signal(SNAME("peer_connected"), id);
|
|
if (server_relay) {
|
|
_notify_peers(id, true);
|
|
}
|
|
return false;
|
|
}
|
|
case ENetConnection::EVENT_DISCONNECT: {
|
|
int id = p_event.peer->get_meta(SNAME("_net_id"));
|
|
if (!peers.has(id)) {
|
|
// Never fully connected.
|
|
return false;
|
|
}
|
|
|
|
emit_signal(SNAME("peer_disconnected"), id);
|
|
peers.erase(id);
|
|
if (server_relay) {
|
|
_notify_peers(id, false);
|
|
}
|
|
return false;
|
|
}
|
|
case ENetConnection::EVENT_RECEIVE: {
|
|
if (p_event.channel_id == SYSCH_CONFIG) {
|
|
_destroy_unused(p_event.packet);
|
|
ERR_FAIL_V_MSG(false, "Only server can send config messages");
|
|
} else {
|
|
if (p_event.packet->dataLength < 8) {
|
|
_destroy_unused(p_event.packet);
|
|
ERR_FAIL_V_MSG(false, "Invalid packet size");
|
|
}
|
|
|
|
uint32_t source = decode_uint32(&p_event.packet->data[0]);
|
|
int target = decode_uint32(&p_event.packet->data[4]);
|
|
|
|
uint32_t id = p_event.peer->get_meta(SNAME("_net_id"));
|
|
// Someone is cheating and trying to fake the source!
|
|
if (source != id) {
|
|
_destroy_unused(p_event.packet);
|
|
ERR_FAIL_V_MSG(false, "Someone is cheating and trying to fake the source!");
|
|
}
|
|
|
|
Packet packet;
|
|
packet.packet = p_event.packet;
|
|
packet.channel = p_event.channel_id;
|
|
packet.from = id;
|
|
|
|
// Even if relaying is disabled, these targets are valid as incoming packets.
|
|
if (target == 1 || target == 0 || target < -1) {
|
|
packet.packet->referenceCount++;
|
|
incoming_packets.push_back(packet);
|
|
}
|
|
|
|
if (server_relay && target != 1) {
|
|
packet.packet->referenceCount++;
|
|
_relay(source, target, p_event.channel_id, p_event.packet);
|
|
packet.packet->referenceCount--;
|
|
_destroy_unused(p_event.packet);
|
|
}
|
|
// Destroy packet later
|
|
}
|
|
return false;
|
|
}
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool ENetMultiplayerPeer::_parse_client_event(ENetConnection::EventType p_type, ENetConnection::Event &p_event) {
|
|
switch (p_type) {
|
|
case ENetConnection::EVENT_CONNECT: {
|
|
connection_status = CONNECTION_CONNECTED;
|
|
emit_signal(SNAME("peer_connected"), 1);
|
|
emit_signal(SNAME("connection_succeeded"));
|
|
return false;
|
|
}
|
|
case ENetConnection::EVENT_DISCONNECT: {
|
|
if (connection_status == CONNECTION_CONNECTED) {
|
|
// Client just disconnected from server.
|
|
emit_signal(SNAME("server_disconnected"));
|
|
} else {
|
|
emit_signal(SNAME("connection_failed"));
|
|
}
|
|
close_connection();
|
|
return true;
|
|
}
|
|
case ENetConnection::EVENT_RECEIVE: {
|
|
if (p_event.channel_id == SYSCH_CONFIG) {
|
|
// Config message
|
|
if (p_event.packet->dataLength != 8) {
|
|
_destroy_unused(p_event.packet);
|
|
ERR_FAIL_V(false);
|
|
}
|
|
|
|
int msg = decode_uint32(&p_event.packet->data[0]);
|
|
int id = decode_uint32(&p_event.packet->data[4]);
|
|
|
|
switch (msg) {
|
|
case SYSMSG_ADD_PEER: {
|
|
peers[id] = Ref<ENetPacketPeer>();
|
|
emit_signal(SNAME("peer_connected"), id);
|
|
|
|
} break;
|
|
case SYSMSG_REMOVE_PEER: {
|
|
peers.erase(id);
|
|
emit_signal(SNAME("peer_disconnected"), id);
|
|
} break;
|
|
}
|
|
_destroy_unused(p_event.packet);
|
|
} else {
|
|
if (p_event.packet->dataLength < 8) {
|
|
_destroy_unused(p_event.packet);
|
|
ERR_FAIL_V_MSG(false, "Invalid packet size");
|
|
}
|
|
|
|
uint32_t source = decode_uint32(&p_event.packet->data[0]);
|
|
Packet packet;
|
|
packet.packet = p_event.packet;
|
|
packet.from = source;
|
|
packet.channel = p_event.channel_id;
|
|
|
|
packet.packet->referenceCount++;
|
|
incoming_packets.push_back(packet);
|
|
// Destroy packet later
|
|
}
|
|
return false;
|
|
}
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
bool ENetMultiplayerPeer::_parse_mesh_event(ENetConnection::EventType p_type, ENetConnection::Event &p_event, int p_peer_id) {
|
|
switch (p_type) {
|
|
case ENetConnection::EVENT_CONNECT:
|
|
p_event.peer->reset();
|
|
return false;
|
|
case ENetConnection::EVENT_DISCONNECT:
|
|
if (peers.has(p_peer_id)) {
|
|
emit_signal(SNAME("peer_disconnected"), p_peer_id);
|
|
peers.erase(p_peer_id);
|
|
}
|
|
hosts.erase(p_peer_id);
|
|
return true;
|
|
case ENetConnection::EVENT_RECEIVE: {
|
|
if (p_event.packet->dataLength < 8) {
|
|
_destroy_unused(p_event.packet);
|
|
ERR_FAIL_V_MSG(false, "Invalid packet size");
|
|
}
|
|
|
|
Packet packet;
|
|
packet.packet = p_event.packet;
|
|
packet.from = p_peer_id;
|
|
packet.channel = p_event.channel_id;
|
|
|
|
packet.packet->referenceCount++;
|
|
incoming_packets.push_back(packet);
|
|
return false;
|
|
} break;
|
|
default:
|
|
// Nothing to do
|
|
return true;
|
|
}
|
|
}
|
|
|
|
void ENetMultiplayerPeer::poll() {
|
|
ERR_FAIL_COND_MSG(!_is_active(), "The multiplayer instance isn't currently active.");
|
|
|
|
_pop_current_packet();
|
|
|
|
switch (active_mode) {
|
|
case MODE_CLIENT: {
|
|
if (peers.has(1) && !peers[1]->is_active()) {
|
|
if (connection_status == CONNECTION_CONNECTED) {
|
|
// Client just disconnected from server.
|
|
emit_signal(SNAME("server_disconnected"));
|
|
} else {
|
|
emit_signal(SNAME("connection_failed"));
|
|
}
|
|
close_connection();
|
|
return;
|
|
}
|
|
ENetConnection::Event event;
|
|
ENetConnection::EventType ret = hosts[0]->service(0, event);
|
|
if (ret == ENetConnection::EVENT_ERROR) {
|
|
return;
|
|
}
|
|
do {
|
|
if (_parse_client_event(ret, event)) {
|
|
return;
|
|
}
|
|
} while (hosts[0]->check_events(ret, event) > 0);
|
|
} break;
|
|
case MODE_SERVER: {
|
|
for (const KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (!(E.value->is_active())) {
|
|
emit_signal(SNAME("peer_disconnected"), E.value->get_meta(SNAME("_net_id")));
|
|
peers.erase(E.key);
|
|
}
|
|
}
|
|
ENetConnection::Event event;
|
|
ENetConnection::EventType ret = hosts[0]->service(0, event);
|
|
if (ret == ENetConnection::EVENT_ERROR) {
|
|
return;
|
|
}
|
|
do {
|
|
if (_parse_server_event(ret, event)) {
|
|
return;
|
|
}
|
|
} while (hosts[0]->check_events(ret, event) > 0);
|
|
} break;
|
|
case MODE_MESH: {
|
|
for (const KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (!(E.value->is_active())) {
|
|
emit_signal(SNAME("peer_disconnected"), E.key);
|
|
peers.erase(E.key);
|
|
if (hosts.has(E.key)) {
|
|
hosts.erase(E.key);
|
|
}
|
|
}
|
|
}
|
|
for (KeyValue<int, Ref<ENetConnection>> &E : hosts) {
|
|
ENetConnection::Event event;
|
|
ENetConnection::EventType ret = E.value->service(0, event);
|
|
if (ret == ENetConnection::EVENT_ERROR) {
|
|
if (peers.has(E.key)) {
|
|
emit_signal(SNAME("peer_disconnected"), E.key);
|
|
peers.erase(E.key);
|
|
}
|
|
hosts.erase(E.key);
|
|
continue;
|
|
}
|
|
do {
|
|
if (_parse_mesh_event(ret, event, E.key)) {
|
|
break; // Keep polling the others.
|
|
}
|
|
} while (E.value->check_events(ret, event) > 0);
|
|
}
|
|
} break;
|
|
default:
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool ENetMultiplayerPeer::is_server() const {
|
|
return active_mode == MODE_SERVER;
|
|
}
|
|
|
|
void ENetMultiplayerPeer::close_connection(uint32_t wait_usec) {
|
|
if (!_is_active()) {
|
|
return;
|
|
}
|
|
|
|
_pop_current_packet();
|
|
|
|
bool peers_disconnected = false;
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.value.is_valid() && E.value->get_state() == ENetPacketPeer::STATE_CONNECTED) {
|
|
E.value->peer_disconnect_now(unique_id);
|
|
peers_disconnected = true;
|
|
}
|
|
}
|
|
|
|
if (peers_disconnected) {
|
|
for (KeyValue<int, Ref<ENetConnection>> &E : hosts) {
|
|
E.value->flush();
|
|
}
|
|
|
|
if (wait_usec > 0) {
|
|
OS::get_singleton()->delay_usec(wait_usec); // Wait for disconnection packets to send
|
|
}
|
|
}
|
|
|
|
active_mode = MODE_NONE;
|
|
incoming_packets.clear();
|
|
peers.clear();
|
|
hosts.clear();
|
|
unique_id = 0;
|
|
connection_status = CONNECTION_DISCONNECTED;
|
|
set_refuse_new_connections(false);
|
|
}
|
|
|
|
int ENetMultiplayerPeer::get_available_packet_count() const {
|
|
return incoming_packets.size();
|
|
}
|
|
|
|
Error ENetMultiplayerPeer::get_packet(const uint8_t **r_buffer, int &r_buffer_size) {
|
|
ERR_FAIL_COND_V_MSG(incoming_packets.size() == 0, ERR_UNAVAILABLE, "No incoming packets available.");
|
|
|
|
_pop_current_packet();
|
|
|
|
current_packet = incoming_packets.front()->get();
|
|
incoming_packets.pop_front();
|
|
|
|
*r_buffer = (const uint8_t *)(¤t_packet.packet->data[8]);
|
|
r_buffer_size = current_packet.packet->dataLength - 8;
|
|
|
|
return OK;
|
|
}
|
|
|
|
Error ENetMultiplayerPeer::put_packet(const uint8_t *p_buffer, int p_buffer_size) {
|
|
ERR_FAIL_COND_V_MSG(!_is_active(), ERR_UNCONFIGURED, "The multiplayer instance isn't currently active.");
|
|
ERR_FAIL_COND_V_MSG(connection_status != CONNECTION_CONNECTED, ERR_UNCONFIGURED, "The multiplayer instance isn't currently connected to any server or client.");
|
|
ERR_FAIL_COND_V_MSG(target_peer != 0 && !peers.has(ABS(target_peer)), ERR_INVALID_PARAMETER, vformat("Invalid target peer: %d", target_peer));
|
|
ERR_FAIL_COND_V(active_mode == MODE_CLIENT && !peers.has(1), ERR_BUG);
|
|
|
|
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 (get_transfer_mode()) {
|
|
case Multiplayer::TRANSFER_MODE_UNRELIABLE: {
|
|
packet_flags = ENET_PACKET_FLAG_UNSEQUENCED | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT;
|
|
channel = SYSCH_UNRELIABLE;
|
|
} break;
|
|
case Multiplayer::TRANSFER_MODE_UNRELIABLE_ORDERED: {
|
|
packet_flags = ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT;
|
|
channel = SYSCH_UNRELIABLE;
|
|
} break;
|
|
case Multiplayer::TRANSFER_MODE_RELIABLE: {
|
|
packet_flags = ENET_PACKET_FLAG_RELIABLE;
|
|
channel = SYSCH_RELIABLE;
|
|
} break;
|
|
}
|
|
}
|
|
|
|
#ifdef DEBUG_ENABLED
|
|
if ((packet_flags & ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT) && p_buffer_size + 8 > ENET_HOST_DEFAULT_MTU) {
|
|
WARN_PRINT_ONCE(vformat("Sending %d bytes unrealiably which is above the MTU (%d), this will result in higher packet loss", p_buffer_size + 8, ENET_HOST_DEFAULT_MTU));
|
|
}
|
|
#endif
|
|
|
|
ENetPacket *packet = enet_packet_create(nullptr, p_buffer_size + 8, packet_flags);
|
|
encode_uint32(unique_id, &packet->data[0]); // Source ID
|
|
encode_uint32(target_peer, &packet->data[4]); // Dest ID
|
|
memcpy(&packet->data[8], p_buffer, p_buffer_size);
|
|
|
|
if (is_server()) {
|
|
if (target_peer == 0) {
|
|
hosts[0]->broadcast(channel, packet);
|
|
|
|
} else if (target_peer < 0) {
|
|
// Send to all but one and make copies for sending.
|
|
int exclude = -target_peer;
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.key == exclude) {
|
|
continue;
|
|
}
|
|
E.value->send(channel, packet);
|
|
}
|
|
_destroy_unused(packet);
|
|
} else {
|
|
peers[target_peer]->send(channel, packet);
|
|
}
|
|
ERR_FAIL_COND_V(!hosts.has(0), ERR_BUG);
|
|
hosts[0]->flush();
|
|
|
|
} else if (active_mode == MODE_CLIENT) {
|
|
peers[1]->send(channel, packet); // Send to server for broadcast.
|
|
ERR_FAIL_COND_V(!hosts.has(0), ERR_BUG);
|
|
hosts[0]->flush();
|
|
|
|
} else {
|
|
if (target_peer <= 0) {
|
|
int exclude = ABS(target_peer);
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.key == exclude) {
|
|
continue;
|
|
}
|
|
E.value->send(channel, packet);
|
|
ERR_CONTINUE(!hosts.has(E.key));
|
|
hosts[E.key]->flush();
|
|
}
|
|
_destroy_unused(packet);
|
|
} else {
|
|
peers[target_peer]->send(channel, packet);
|
|
ERR_FAIL_COND_V(!hosts.has(target_peer), ERR_BUG);
|
|
hosts[target_peer]->flush();
|
|
}
|
|
}
|
|
|
|
return OK;
|
|
}
|
|
|
|
int ENetMultiplayerPeer::get_max_packet_size() const {
|
|
return 1 << 24; // Anything is good
|
|
}
|
|
|
|
void ENetMultiplayerPeer::_pop_current_packet() {
|
|
if (current_packet.packet) {
|
|
current_packet.packet->referenceCount--;
|
|
_destroy_unused(current_packet.packet);
|
|
current_packet.packet = nullptr;
|
|
current_packet.from = 0;
|
|
current_packet.channel = -1;
|
|
}
|
|
}
|
|
|
|
MultiplayerPeer::ConnectionStatus ENetMultiplayerPeer::get_connection_status() const {
|
|
return connection_status;
|
|
}
|
|
|
|
int ENetMultiplayerPeer::get_unique_id() const {
|
|
ERR_FAIL_COND_V_MSG(!_is_active(), 0, "The multiplayer instance isn't currently active.");
|
|
return unique_id;
|
|
}
|
|
|
|
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_enabled);
|
|
}
|
|
}
|
|
#endif
|
|
MultiplayerPeer::set_refuse_new_connections(p_enabled);
|
|
}
|
|
|
|
void ENetMultiplayerPeer::set_server_relay_enabled(bool p_enabled) {
|
|
ERR_FAIL_COND_MSG(_is_active(), "Server relaying can't be toggled while the multiplayer instance is active.");
|
|
|
|
server_relay = p_enabled;
|
|
}
|
|
|
|
bool ENetMultiplayerPeer::is_server_relay_enabled() const {
|
|
return server_relay;
|
|
}
|
|
|
|
Ref<ENetConnection> ENetMultiplayerPeer::get_host() const {
|
|
ERR_FAIL_COND_V(!_is_active(), nullptr);
|
|
ERR_FAIL_COND_V(active_mode == MODE_MESH, nullptr);
|
|
return hosts[0];
|
|
}
|
|
|
|
Ref<ENetPacketPeer> ENetMultiplayerPeer::get_peer(int p_id) const {
|
|
ERR_FAIL_COND_V(!_is_active(), nullptr);
|
|
ERR_FAIL_COND_V(!peers.has(p_id), nullptr);
|
|
ERR_FAIL_COND_V(active_mode == MODE_CLIENT && p_id != 1, nullptr);
|
|
return peers[p_id];
|
|
}
|
|
|
|
void ENetMultiplayerPeer::_destroy_unused(ENetPacket *p_packet) {
|
|
if (p_packet->referenceCount == 0) {
|
|
enet_packet_destroy(p_packet);
|
|
}
|
|
}
|
|
|
|
void ENetMultiplayerPeer::_relay(int p_from, int p_to, enet_uint8 p_channel, ENetPacket *p_packet) {
|
|
if (p_to == 0) {
|
|
// Re-send to everyone but sender :|
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.key == p_from) {
|
|
continue;
|
|
}
|
|
|
|
E.value->send(p_channel, p_packet);
|
|
}
|
|
} else if (p_to < 0) {
|
|
// Re-send to everyone but excluded and sender.
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.key == p_from || E.key == -p_to) { // Do not resend to self, also do not send to excluded
|
|
continue;
|
|
}
|
|
|
|
E.value->send(p_channel, p_packet);
|
|
}
|
|
} else {
|
|
// To someone else, specifically
|
|
ERR_FAIL_COND(!peers.has(p_to));
|
|
ENetPacket *packet = enet_packet_create(p_packet->data, p_packet->dataLength, p_packet->flags);
|
|
peers[p_to]->send(p_channel, packet);
|
|
}
|
|
}
|
|
|
|
void ENetMultiplayerPeer::_notify_peers(int p_id, bool p_connected) {
|
|
if (p_connected) {
|
|
ERR_FAIL_COND(!peers.has(p_id));
|
|
// Someone connected, notify all the peers available.
|
|
Ref<ENetPacketPeer> peer = peers[p_id];
|
|
ENetPacket *packet = enet_packet_create(nullptr, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]);
|
|
encode_uint32(p_id, &packet->data[4]);
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.key == p_id) {
|
|
continue;
|
|
}
|
|
// Send new peer to existing peer.
|
|
E.value->send(SYSCH_CONFIG, packet);
|
|
// Send existing peer to new peer.
|
|
// This packet will be automatically destroyed by ENet after send.
|
|
ENetPacket *packet2 = enet_packet_create(nullptr, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_ADD_PEER, &packet2->data[0]);
|
|
encode_uint32(E.key, &packet2->data[4]);
|
|
peer->send(SYSCH_CONFIG, packet2);
|
|
}
|
|
_destroy_unused(packet);
|
|
} else {
|
|
// Server just received a client disconnect and is in relay mode, notify everyone else.
|
|
ENetPacket *packet = enet_packet_create(nullptr, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_REMOVE_PEER, &packet->data[0]);
|
|
encode_uint32(p_id, &packet->data[4]);
|
|
for (KeyValue<int, Ref<ENetPacketPeer>> &E : peers) {
|
|
if (E.key == p_id) {
|
|
continue;
|
|
}
|
|
E.value->send(SYSCH_CONFIG, packet);
|
|
}
|
|
_destroy_unused(packet);
|
|
}
|
|
}
|
|
|
|
void ENetMultiplayerPeer::_bind_methods() {
|
|
ClassDB::bind_method(D_METHOD("create_server", "port", "max_clients", "max_channels", "in_bandwidth", "out_bandwidth"), &ENetMultiplayerPeer::create_server, DEFVAL(32), DEFVAL(0), DEFVAL(0), DEFVAL(0));
|
|
ClassDB::bind_method(D_METHOD("create_client", "address", "port", "channel_count", "in_bandwidth", "out_bandwidth", "local_port"), &ENetMultiplayerPeer::create_client, DEFVAL(0), DEFVAL(0), DEFVAL(0), DEFVAL(0));
|
|
ClassDB::bind_method(D_METHOD("create_mesh", "unique_id"), &ENetMultiplayerPeer::create_mesh);
|
|
ClassDB::bind_method(D_METHOD("add_mesh_peer", "peer_id", "host"), &ENetMultiplayerPeer::add_mesh_peer);
|
|
ClassDB::bind_method(D_METHOD("close_connection", "wait_usec"), &ENetMultiplayerPeer::close_connection, DEFVAL(100));
|
|
ClassDB::bind_method(D_METHOD("set_bind_ip", "ip"), &ENetMultiplayerPeer::set_bind_ip);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_server_relay_enabled", "enabled"), &ENetMultiplayerPeer::set_server_relay_enabled);
|
|
ClassDB::bind_method(D_METHOD("is_server_relay_enabled"), &ENetMultiplayerPeer::is_server_relay_enabled);
|
|
ClassDB::bind_method(D_METHOD("get_host"), &ENetMultiplayerPeer::get_host);
|
|
ClassDB::bind_method(D_METHOD("get_peer", "id"), &ENetMultiplayerPeer::get_peer);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "server_relay"), "set_server_relay_enabled", "is_server_relay_enabled");
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "host", PROPERTY_HINT_RESOURCE_TYPE, "ENetConnection", PROPERTY_USAGE_NONE), "", "get_host");
|
|
}
|
|
|
|
ENetMultiplayerPeer::ENetMultiplayerPeer() {
|
|
bind_ip = IPAddress("*");
|
|
}
|
|
|
|
ENetMultiplayerPeer::~ENetMultiplayerPeer() {
|
|
if (_is_active()) {
|
|
close_connection();
|
|
}
|
|
}
|
|
|
|
// Sets IP for ENet to bind when using create_server or create_client
|
|
// if no IP is set, then ENet bind to ENET_HOST_ANY
|
|
void ENetMultiplayerPeer::set_bind_ip(const IPAddress &p_ip) {
|
|
ERR_FAIL_COND_MSG(!p_ip.is_valid() && !p_ip.is_wildcard(), vformat("Invalid bind IP address: %s", String(p_ip)));
|
|
|
|
bind_ip = p_ip;
|
|
}
|