6d16f2f053
It's not necessary, but the vast majority of calls of error macros do have an ending semicolon, so it's best to be consistent. Most WARN_DEPRECATED calls did *not* have a semicolon, but there's no reason for them to be treated differently.
893 lines
26 KiB
C++
893 lines
26 KiB
C++
/*************************************************************************/
|
|
/* networked_multiplayer_enet.cpp */
|
|
/*************************************************************************/
|
|
/* This file is part of: */
|
|
/* GODOT ENGINE */
|
|
/* https://godotengine.org */
|
|
/*************************************************************************/
|
|
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur. */
|
|
/* Copyright (c) 2014-2019 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 "networked_multiplayer_enet.h"
|
|
#include "core/io/ip.h"
|
|
#include "core/io/marshalls.h"
|
|
#include "core/os/os.h"
|
|
|
|
void NetworkedMultiplayerENet::set_transfer_mode(TransferMode p_mode) {
|
|
|
|
transfer_mode = p_mode;
|
|
}
|
|
NetworkedMultiplayerPeer::TransferMode NetworkedMultiplayerENet::get_transfer_mode() const {
|
|
|
|
return transfer_mode;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::set_target_peer(int p_peer) {
|
|
|
|
target_peer = p_peer;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_packet_peer() const {
|
|
|
|
ERR_FAIL_COND_V(!active, 1);
|
|
ERR_FAIL_COND_V(incoming_packets.size() == 0, 1);
|
|
|
|
return incoming_packets.front()->get().from;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_packet_channel() const {
|
|
|
|
ERR_FAIL_COND_V(!active, -1);
|
|
ERR_FAIL_COND_V(incoming_packets.size() == 0, -1);
|
|
|
|
return incoming_packets.front()->get().channel;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_last_packet_channel() const {
|
|
|
|
ERR_FAIL_COND_V(!active, -1);
|
|
ERR_FAIL_COND_V(!current_packet.packet, -1);
|
|
|
|
return current_packet.channel;
|
|
}
|
|
|
|
Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int p_in_bandwidth, int p_out_bandwidth) {
|
|
|
|
ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE);
|
|
ERR_FAIL_COND_V(p_port < 0 || p_port > 65535, ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_max_clients < 0, ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_in_bandwidth < 0, ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_out_bandwidth < 0, ERR_INVALID_PARAMETER);
|
|
|
|
ENetAddress address;
|
|
|
|
#ifdef GODOT_ENET
|
|
if (bind_ip.is_wildcard()) {
|
|
address.wildcard = 1;
|
|
} else {
|
|
enet_address_set_ip(&address, bind_ip.get_ipv6(), 16);
|
|
}
|
|
#else
|
|
if (bind_ip.is_wildcard()) {
|
|
address.host = 0;
|
|
} else {
|
|
ERR_FAIL_COND_V(!bind_ip.is_ipv4(), ERR_INVALID_PARAMETER);
|
|
address.host = *(uint32_t *)bind_ip.get_ipv4();
|
|
}
|
|
#endif
|
|
address.port = p_port;
|
|
|
|
host = enet_host_create(&address /* the address to bind the server host to */,
|
|
p_max_clients /* allow up to 32 clients and/or outgoing connections */,
|
|
channel_count /* allow up to channel_count to be used */,
|
|
p_in_bandwidth /* limit incoming bandwidth if > 0 */,
|
|
p_out_bandwidth /* limit outgoing bandwidth if > 0 */);
|
|
|
|
ERR_FAIL_COND_V(!host, ERR_CANT_CREATE);
|
|
|
|
_setup_compressor();
|
|
active = true;
|
|
server = true;
|
|
refuse_connections = false;
|
|
unique_id = 1;
|
|
connection_status = CONNECTION_CONNECTED;
|
|
return OK;
|
|
}
|
|
Error NetworkedMultiplayerENet::create_client(const String &p_address, int p_port, int p_in_bandwidth, int p_out_bandwidth, int p_client_port) {
|
|
|
|
ERR_FAIL_COND_V(active, ERR_ALREADY_IN_USE);
|
|
ERR_FAIL_COND_V(p_port < 0 || p_port > 65535, ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_client_port < 0 || p_client_port > 65535, ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_in_bandwidth < 0, ERR_INVALID_PARAMETER);
|
|
ERR_FAIL_COND_V(p_out_bandwidth < 0, ERR_INVALID_PARAMETER);
|
|
|
|
if (p_client_port != 0) {
|
|
ENetAddress c_client;
|
|
|
|
#ifdef GODOT_ENET
|
|
if (bind_ip.is_wildcard()) {
|
|
c_client.wildcard = 1;
|
|
} else {
|
|
enet_address_set_ip(&c_client, bind_ip.get_ipv6(), 16);
|
|
}
|
|
#else
|
|
if (bind_ip.is_wildcard()) {
|
|
c_client.host = 0;
|
|
} else {
|
|
ERR_FAIL_COND_V(!bind_ip.is_ipv4(), ERR_INVALID_PARAMETER);
|
|
c_client.host = *(uint32_t *)bind_ip.get_ipv4();
|
|
}
|
|
#endif
|
|
|
|
c_client.port = p_client_port;
|
|
|
|
host = enet_host_create(&c_client /* create a client host */,
|
|
1 /* only allow 1 outgoing connection */,
|
|
channel_count /* allow up to channel_count to be used */,
|
|
p_in_bandwidth /* limit incoming bandwidth if > 0 */,
|
|
p_out_bandwidth /* limit outgoing bandwidth if > 0 */);
|
|
} else {
|
|
host = enet_host_create(NULL /* create a client host */,
|
|
1 /* only allow 1 outgoing connection */,
|
|
channel_count /* allow up to channel_count to be used */,
|
|
p_in_bandwidth /* limit incoming bandwidth if > 0 */,
|
|
p_out_bandwidth /* limit outgoing bandwidth if > 0 */);
|
|
}
|
|
|
|
ERR_FAIL_COND_V(!host, ERR_CANT_CREATE);
|
|
|
|
_setup_compressor();
|
|
|
|
IP_Address ip;
|
|
if (p_address.is_valid_ip_address()) {
|
|
ip = p_address;
|
|
} else {
|
|
#ifdef GODOT_ENET
|
|
ip = IP::get_singleton()->resolve_hostname(p_address);
|
|
#else
|
|
ip = IP::get_singleton()->resolve_hostname(p_address, IP::TYPE_IPV4);
|
|
#endif
|
|
|
|
ERR_FAIL_COND_V(!ip.is_valid(), ERR_CANT_RESOLVE);
|
|
}
|
|
|
|
ENetAddress address;
|
|
#ifdef GODOT_ENET
|
|
enet_address_set_ip(&address, ip.get_ipv6(), 16);
|
|
#else
|
|
ERR_FAIL_COND_V(!ip.is_ipv4(), ERR_INVALID_PARAMETER);
|
|
address.host = *(uint32_t *)ip.get_ipv4();
|
|
#endif
|
|
address.port = p_port;
|
|
|
|
unique_id = _gen_unique_id();
|
|
|
|
// Initiate connection, allocating enough channels
|
|
ENetPeer *peer = enet_host_connect(host, &address, channel_count, unique_id);
|
|
|
|
if (peer == NULL) {
|
|
enet_host_destroy(host);
|
|
ERR_FAIL_COND_V(!peer, ERR_CANT_CREATE);
|
|
}
|
|
|
|
// Technically safe to ignore the peer or anything else.
|
|
|
|
connection_status = CONNECTION_CONNECTING;
|
|
active = true;
|
|
server = false;
|
|
refuse_connections = false;
|
|
|
|
return OK;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::poll() {
|
|
|
|
ERR_FAIL_COND(!active);
|
|
|
|
_pop_current_packet();
|
|
|
|
ENetEvent event;
|
|
/* Keep servicing until there are no available events left in queue. */
|
|
while (true) {
|
|
|
|
if (!host || !active) // Might have been disconnected while emitting a notification
|
|
return;
|
|
|
|
int ret = enet_host_service(host, &event, 0);
|
|
|
|
if (ret < 0) {
|
|
// Error, do something?
|
|
break;
|
|
} else if (ret == 0) {
|
|
break;
|
|
}
|
|
|
|
switch (event.type) {
|
|
case ENET_EVENT_TYPE_CONNECT: {
|
|
// Store any relevant client information here.
|
|
|
|
if (server && refuse_connections) {
|
|
enet_peer_reset(event.peer);
|
|
break;
|
|
}
|
|
|
|
// A client joined with an invalid ID (negative values, 0, and 1 are reserved).
|
|
// Probably trying to exploit us.
|
|
if (server && ((int)event.data < 2 || peer_map.has((int)event.data))) {
|
|
enet_peer_reset(event.peer);
|
|
ERR_CONTINUE(true);
|
|
}
|
|
|
|
int *new_id = memnew(int);
|
|
*new_id = event.data;
|
|
|
|
if (*new_id == 0) { // Data zero is sent by server (enet won't let you configure this). Server is always 1.
|
|
*new_id = 1;
|
|
}
|
|
|
|
event.peer->data = new_id;
|
|
|
|
peer_map[*new_id] = event.peer;
|
|
|
|
connection_status = CONNECTION_CONNECTED; // If connecting, this means it connected to something!
|
|
|
|
emit_signal("peer_connected", *new_id);
|
|
|
|
if (server) {
|
|
// Someone connected, notify all the peers available
|
|
for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
|
|
|
|
if (E->key() == *new_id)
|
|
continue;
|
|
// Send existing peers to new peer
|
|
ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]);
|
|
encode_uint32(E->key(), &packet->data[4]);
|
|
enet_peer_send(event.peer, SYSCH_CONFIG, packet);
|
|
// Send the new peer to existing peers
|
|
packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_ADD_PEER, &packet->data[0]);
|
|
encode_uint32(*new_id, &packet->data[4]);
|
|
enet_peer_send(E->get(), SYSCH_CONFIG, packet);
|
|
}
|
|
} else {
|
|
|
|
emit_signal("connection_succeeded");
|
|
}
|
|
|
|
} break;
|
|
case ENET_EVENT_TYPE_DISCONNECT: {
|
|
|
|
// Reset the peer's client information.
|
|
|
|
int *id = (int *)event.peer->data;
|
|
|
|
if (!id) {
|
|
if (!server) {
|
|
emit_signal("connection_failed");
|
|
}
|
|
} else {
|
|
|
|
if (server) {
|
|
// Someone disconnected, notify everyone else
|
|
for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
|
|
|
|
if (E->key() == *id)
|
|
continue;
|
|
|
|
ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_REMOVE_PEER, &packet->data[0]);
|
|
encode_uint32(*id, &packet->data[4]);
|
|
enet_peer_send(E->get(), SYSCH_CONFIG, packet);
|
|
}
|
|
} else {
|
|
emit_signal("server_disconnected");
|
|
close_connection();
|
|
return;
|
|
}
|
|
|
|
emit_signal("peer_disconnected", *id);
|
|
peer_map.erase(*id);
|
|
memdelete(id);
|
|
}
|
|
|
|
} break;
|
|
case ENET_EVENT_TYPE_RECEIVE: {
|
|
|
|
if (event.channelID == SYSCH_CONFIG) {
|
|
// Some config message
|
|
ERR_CONTINUE(event.packet->dataLength < 8);
|
|
|
|
// Only server can send config messages
|
|
ERR_CONTINUE(server);
|
|
|
|
int msg = decode_uint32(&event.packet->data[0]);
|
|
int id = decode_uint32(&event.packet->data[4]);
|
|
|
|
switch (msg) {
|
|
case SYSMSG_ADD_PEER: {
|
|
|
|
peer_map[id] = NULL;
|
|
emit_signal("peer_connected", id);
|
|
|
|
} break;
|
|
case SYSMSG_REMOVE_PEER: {
|
|
|
|
peer_map.erase(id);
|
|
emit_signal("peer_disconnected", id);
|
|
} break;
|
|
}
|
|
|
|
enet_packet_destroy(event.packet);
|
|
} else if (event.channelID < channel_count) {
|
|
|
|
Packet packet;
|
|
packet.packet = event.packet;
|
|
|
|
uint32_t *id = (uint32_t *)event.peer->data;
|
|
|
|
ERR_CONTINUE(event.packet->dataLength < 8);
|
|
|
|
uint32_t source = decode_uint32(&event.packet->data[0]);
|
|
int target = decode_uint32(&event.packet->data[4]);
|
|
|
|
packet.from = source;
|
|
packet.channel = event.channelID;
|
|
|
|
if (server) {
|
|
// Someone is cheating and trying to fake the source!
|
|
ERR_CONTINUE(source != *id);
|
|
|
|
packet.from = *id;
|
|
|
|
if (target == 0) {
|
|
// Re-send to everyone but sender :|
|
|
|
|
incoming_packets.push_back(packet);
|
|
// And make copies for sending
|
|
for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
|
|
|
|
if (uint32_t(E->key()) == source) // Do not resend to self
|
|
continue;
|
|
|
|
ENetPacket *packet2 = enet_packet_create(packet.packet->data, packet.packet->dataLength, packet.packet->flags);
|
|
|
|
enet_peer_send(E->get(), event.channelID, packet2);
|
|
}
|
|
|
|
} else if (target < 0) {
|
|
// To all but one
|
|
|
|
// And make copies for sending
|
|
for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
|
|
|
|
if (uint32_t(E->key()) == source || E->key() == -target) // Do not resend to self, also do not send to excluded
|
|
continue;
|
|
|
|
ENetPacket *packet2 = enet_packet_create(packet.packet->data, packet.packet->dataLength, packet.packet->flags);
|
|
|
|
enet_peer_send(E->get(), event.channelID, packet2);
|
|
}
|
|
|
|
if (-target != 1) {
|
|
// Server is not excluded
|
|
incoming_packets.push_back(packet);
|
|
} else {
|
|
// Server is excluded, erase packet
|
|
enet_packet_destroy(packet.packet);
|
|
}
|
|
|
|
} else if (target == 1) {
|
|
// To myself and only myself
|
|
incoming_packets.push_back(packet);
|
|
} else {
|
|
// To someone else, specifically
|
|
ERR_CONTINUE(!peer_map.has(target));
|
|
enet_peer_send(peer_map[target], event.channelID, packet.packet);
|
|
}
|
|
} else {
|
|
|
|
incoming_packets.push_back(packet);
|
|
}
|
|
|
|
// Destroy packet later
|
|
} else {
|
|
ERR_CONTINUE(true);
|
|
}
|
|
|
|
} break;
|
|
case ENET_EVENT_TYPE_NONE: {
|
|
// Do nothing
|
|
} break;
|
|
}
|
|
}
|
|
}
|
|
|
|
bool NetworkedMultiplayerENet::is_server() const {
|
|
ERR_FAIL_COND_V(!active, false);
|
|
|
|
return server;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::close_connection(uint32_t wait_usec) {
|
|
|
|
ERR_FAIL_COND(!active);
|
|
|
|
_pop_current_packet();
|
|
|
|
bool peers_disconnected = false;
|
|
for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
|
|
if (E->get()) {
|
|
enet_peer_disconnect_now(E->get(), unique_id);
|
|
peers_disconnected = true;
|
|
}
|
|
}
|
|
|
|
if (peers_disconnected) {
|
|
enet_host_flush(host);
|
|
|
|
if (wait_usec > 0) {
|
|
OS::get_singleton()->delay_usec(wait_usec); // Wait for disconnection packets to send
|
|
}
|
|
}
|
|
|
|
enet_host_destroy(host);
|
|
active = false;
|
|
incoming_packets.clear();
|
|
unique_id = 1; // Server is 1
|
|
connection_status = CONNECTION_DISCONNECTED;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::disconnect_peer(int p_peer, bool now) {
|
|
|
|
ERR_FAIL_COND(!active);
|
|
ERR_FAIL_COND(!is_server());
|
|
ERR_FAIL_COND(!peer_map.has(p_peer));
|
|
|
|
if (now) {
|
|
enet_peer_disconnect_now(peer_map[p_peer], 0);
|
|
|
|
// enet_peer_disconnect_now doesn't generate ENET_EVENT_TYPE_DISCONNECT,
|
|
// notify everyone else, send disconnect signal & remove from peer_map like in poll()
|
|
|
|
for (Map<int, ENetPeer *>::Element *E = peer_map.front(); E; E = E->next()) {
|
|
|
|
if (E->key() == p_peer)
|
|
continue;
|
|
|
|
ENetPacket *packet = enet_packet_create(NULL, 8, ENET_PACKET_FLAG_RELIABLE);
|
|
encode_uint32(SYSMSG_REMOVE_PEER, &packet->data[0]);
|
|
encode_uint32(p_peer, &packet->data[4]);
|
|
enet_peer_send(E->get(), SYSCH_CONFIG, packet);
|
|
}
|
|
|
|
emit_signal("peer_disconnected", p_peer);
|
|
peer_map.erase(p_peer);
|
|
} else {
|
|
enet_peer_disconnect_later(peer_map[p_peer], 0);
|
|
}
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_available_packet_count() const {
|
|
|
|
return incoming_packets.size();
|
|
}
|
|
|
|
Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer, int &r_buffer_size) {
|
|
|
|
ERR_FAIL_COND_V(incoming_packets.size() == 0, ERR_UNAVAILABLE);
|
|
|
|
_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 NetworkedMultiplayerENet::put_packet(const uint8_t *p_buffer, int p_buffer_size) {
|
|
|
|
ERR_FAIL_COND_V(!active, ERR_UNCONFIGURED);
|
|
ERR_FAIL_COND_V(connection_status != CONNECTION_CONNECTED, ERR_UNCONFIGURED);
|
|
|
|
int packet_flags = 0;
|
|
int channel = SYSCH_RELIABLE;
|
|
|
|
switch (transfer_mode) {
|
|
case TRANSFER_MODE_UNRELIABLE: {
|
|
if (always_ordered)
|
|
packet_flags = 0;
|
|
else
|
|
packet_flags = ENET_PACKET_FLAG_UNSEQUENCED;
|
|
channel = SYSCH_UNRELIABLE;
|
|
} break;
|
|
case TRANSFER_MODE_UNRELIABLE_ORDERED: {
|
|
packet_flags = 0;
|
|
channel = SYSCH_UNRELIABLE;
|
|
} break;
|
|
case TRANSFER_MODE_RELIABLE: {
|
|
packet_flags = ENET_PACKET_FLAG_RELIABLE;
|
|
channel = SYSCH_RELIABLE;
|
|
} break;
|
|
}
|
|
|
|
if (transfer_channel > SYSCH_CONFIG)
|
|
channel = transfer_channel;
|
|
|
|
Map<int, ENetPeer *>::Element *E = NULL;
|
|
|
|
if (target_peer != 0) {
|
|
|
|
E = peer_map.find(ABS(target_peer));
|
|
if (!E) {
|
|
ERR_EXPLAIN("Invalid Target Peer: " + itos(target_peer));
|
|
ERR_FAIL_V(ERR_INVALID_PARAMETER);
|
|
}
|
|
}
|
|
|
|
ENetPacket *packet = enet_packet_create(NULL, p_buffer_size + 8, packet_flags);
|
|
encode_uint32(unique_id, &packet->data[0]); // Source ID
|
|
encode_uint32(target_peer, &packet->data[4]); // Dest ID
|
|
copymem(&packet->data[8], p_buffer, p_buffer_size);
|
|
|
|
if (server) {
|
|
|
|
if (target_peer == 0) {
|
|
enet_host_broadcast(host, channel, packet);
|
|
} else if (target_peer < 0) {
|
|
// Send to all but one
|
|
// and make copies for sending
|
|
|
|
int exclude = -target_peer;
|
|
|
|
for (Map<int, ENetPeer *>::Element *F = peer_map.front(); F; F = F->next()) {
|
|
|
|
if (F->key() == exclude) // Exclude packet
|
|
continue;
|
|
|
|
ENetPacket *packet2 = enet_packet_create(packet->data, packet->dataLength, packet_flags);
|
|
|
|
enet_peer_send(F->get(), channel, packet2);
|
|
}
|
|
|
|
enet_packet_destroy(packet); // Original packet no longer needed
|
|
} else {
|
|
enet_peer_send(E->get(), channel, packet);
|
|
}
|
|
} else {
|
|
|
|
ERR_FAIL_COND_V(!peer_map.has(1), ERR_BUG);
|
|
enet_peer_send(peer_map[1], channel, packet); // Send to server for broadcast
|
|
}
|
|
|
|
enet_host_flush(host);
|
|
|
|
return OK;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_max_packet_size() const {
|
|
|
|
return 1 << 24; // Anything is good
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::_pop_current_packet() {
|
|
|
|
if (current_packet.packet) {
|
|
enet_packet_destroy(current_packet.packet);
|
|
current_packet.packet = NULL;
|
|
current_packet.from = 0;
|
|
current_packet.channel = -1;
|
|
}
|
|
}
|
|
|
|
NetworkedMultiplayerPeer::ConnectionStatus NetworkedMultiplayerENet::get_connection_status() const {
|
|
|
|
return connection_status;
|
|
}
|
|
|
|
uint32_t NetworkedMultiplayerENet::_gen_unique_id() const {
|
|
|
|
uint32_t hash = 0;
|
|
|
|
while (hash == 0 || hash == 1) {
|
|
|
|
hash = hash_djb2_one_32(
|
|
(uint32_t)OS::get_singleton()->get_ticks_usec());
|
|
hash = hash_djb2_one_32(
|
|
(uint32_t)OS::get_singleton()->get_unix_time(), hash);
|
|
hash = hash_djb2_one_32(
|
|
(uint32_t)OS::get_singleton()->get_user_data_dir().hash64(), hash);
|
|
hash = hash_djb2_one_32(
|
|
(uint32_t)((uint64_t)this), hash); // Rely on ASLR heap
|
|
hash = hash_djb2_one_32(
|
|
(uint32_t)((uint64_t)&hash), hash); // Rely on ASLR stack
|
|
|
|
hash = hash & 0x7FFFFFFF; // Make it compatible with unsigned, since negative ID is used for exclusion
|
|
}
|
|
|
|
return hash;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_unique_id() const {
|
|
|
|
ERR_FAIL_COND_V(!active, 0);
|
|
return unique_id;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::set_refuse_new_connections(bool p_enable) {
|
|
|
|
refuse_connections = p_enable;
|
|
}
|
|
|
|
bool NetworkedMultiplayerENet::is_refusing_new_connections() const {
|
|
|
|
return refuse_connections;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::set_compression_mode(CompressionMode p_mode) {
|
|
|
|
compression_mode = p_mode;
|
|
}
|
|
|
|
NetworkedMultiplayerENet::CompressionMode NetworkedMultiplayerENet::get_compression_mode() const {
|
|
|
|
return compression_mode;
|
|
}
|
|
|
|
size_t NetworkedMultiplayerENet::enet_compress(void *context, const ENetBuffer *inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 *outData, size_t outLimit) {
|
|
|
|
NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet *)(context);
|
|
|
|
if (size_t(enet->src_compressor_mem.size()) < inLimit) {
|
|
enet->src_compressor_mem.resize(inLimit);
|
|
}
|
|
|
|
int total = inLimit;
|
|
int ofs = 0;
|
|
while (total) {
|
|
for (size_t i = 0; i < inBufferCount; i++) {
|
|
int to_copy = MIN(total, int(inBuffers[i].dataLength));
|
|
copymem(&enet->src_compressor_mem.write[ofs], inBuffers[i].data, to_copy);
|
|
ofs += to_copy;
|
|
total -= to_copy;
|
|
}
|
|
}
|
|
|
|
Compression::Mode mode;
|
|
|
|
switch (enet->compression_mode) {
|
|
case COMPRESS_FASTLZ: {
|
|
mode = Compression::MODE_FASTLZ;
|
|
} break;
|
|
case COMPRESS_ZLIB: {
|
|
mode = Compression::MODE_DEFLATE;
|
|
} break;
|
|
case COMPRESS_ZSTD: {
|
|
mode = Compression::MODE_ZSTD;
|
|
} break;
|
|
default: {
|
|
ERR_FAIL_V(0);
|
|
}
|
|
}
|
|
|
|
int req_size = Compression::get_max_compressed_buffer_size(ofs, mode);
|
|
if (enet->dst_compressor_mem.size() < req_size) {
|
|
enet->dst_compressor_mem.resize(req_size);
|
|
}
|
|
int ret = Compression::compress(enet->dst_compressor_mem.ptrw(), enet->src_compressor_mem.ptr(), ofs, mode);
|
|
|
|
if (ret < 0)
|
|
return 0;
|
|
|
|
if (ret > int(outLimit))
|
|
return 0; // Do not bother
|
|
|
|
copymem(outData, enet->dst_compressor_mem.ptr(), ret);
|
|
|
|
return ret;
|
|
}
|
|
|
|
size_t NetworkedMultiplayerENet::enet_decompress(void *context, const enet_uint8 *inData, size_t inLimit, enet_uint8 *outData, size_t outLimit) {
|
|
|
|
NetworkedMultiplayerENet *enet = (NetworkedMultiplayerENet *)(context);
|
|
int ret = -1;
|
|
switch (enet->compression_mode) {
|
|
case COMPRESS_FASTLZ: {
|
|
|
|
ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_FASTLZ);
|
|
} break;
|
|
case COMPRESS_ZLIB: {
|
|
|
|
ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_DEFLATE);
|
|
} break;
|
|
case COMPRESS_ZSTD: {
|
|
|
|
ret = Compression::decompress(outData, outLimit, inData, inLimit, Compression::MODE_ZSTD);
|
|
} break;
|
|
default: {
|
|
}
|
|
}
|
|
if (ret < 0) {
|
|
return 0;
|
|
} else {
|
|
return ret;
|
|
}
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::_setup_compressor() {
|
|
|
|
switch (compression_mode) {
|
|
|
|
case COMPRESS_NONE: {
|
|
|
|
enet_host_compress(host, NULL);
|
|
} break;
|
|
case COMPRESS_RANGE_CODER: {
|
|
enet_host_compress_with_range_coder(host);
|
|
} break;
|
|
case COMPRESS_FASTLZ:
|
|
case COMPRESS_ZLIB:
|
|
case COMPRESS_ZSTD: {
|
|
|
|
enet_host_compress(host, &enet_compressor);
|
|
} break;
|
|
}
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::enet_compressor_destroy(void *context) {
|
|
|
|
// Nothing to do
|
|
}
|
|
|
|
IP_Address NetworkedMultiplayerENet::get_peer_address(int p_peer_id) const {
|
|
|
|
ERR_FAIL_COND_V(!peer_map.has(p_peer_id), IP_Address());
|
|
ERR_FAIL_COND_V(!is_server() && p_peer_id != 1, IP_Address());
|
|
ERR_FAIL_COND_V(peer_map[p_peer_id] == NULL, IP_Address());
|
|
|
|
IP_Address out;
|
|
#ifdef GODOT_ENET
|
|
out.set_ipv6((uint8_t *)&(peer_map[p_peer_id]->address.host));
|
|
#else
|
|
out.set_ipv4((uint8_t *)&(peer_map[p_peer_id]->address.host));
|
|
#endif
|
|
|
|
return out;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_peer_port(int p_peer_id) const {
|
|
|
|
ERR_FAIL_COND_V(!peer_map.has(p_peer_id), 0);
|
|
ERR_FAIL_COND_V(!is_server() && p_peer_id != 1, 0);
|
|
ERR_FAIL_COND_V(peer_map[p_peer_id] == NULL, 0);
|
|
#ifdef GODOT_ENET
|
|
return peer_map[p_peer_id]->address.port;
|
|
#else
|
|
return peer_map[p_peer_id]->address.port;
|
|
#endif
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::set_transfer_channel(int p_channel) {
|
|
|
|
ERR_FAIL_COND(p_channel < -1 || p_channel >= channel_count);
|
|
|
|
if (p_channel == SYSCH_CONFIG) {
|
|
ERR_EXPLAIN("Channel " + itos(SYSCH_CONFIG) + " is reserved");
|
|
ERR_FAIL();
|
|
}
|
|
transfer_channel = p_channel;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_transfer_channel() const {
|
|
return transfer_channel;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::set_channel_count(int p_channel) {
|
|
|
|
ERR_FAIL_COND(active);
|
|
ERR_FAIL_COND(p_channel < SYSCH_MAX);
|
|
channel_count = p_channel;
|
|
}
|
|
|
|
int NetworkedMultiplayerENet::get_channel_count() const {
|
|
return channel_count;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::set_always_ordered(bool p_ordered) {
|
|
always_ordered = p_ordered;
|
|
}
|
|
|
|
bool NetworkedMultiplayerENet::is_always_ordered() const {
|
|
return always_ordered;
|
|
}
|
|
|
|
void NetworkedMultiplayerENet::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("create_server", "port", "max_clients", "in_bandwidth", "out_bandwidth"), &NetworkedMultiplayerENet::create_server, DEFVAL(32), DEFVAL(0), DEFVAL(0));
|
|
ClassDB::bind_method(D_METHOD("create_client", "address", "port", "in_bandwidth", "out_bandwidth", "client_port"), &NetworkedMultiplayerENet::create_client, DEFVAL(0), DEFVAL(0), DEFVAL(0));
|
|
ClassDB::bind_method(D_METHOD("close_connection", "wait_usec"), &NetworkedMultiplayerENet::close_connection, DEFVAL(100));
|
|
ClassDB::bind_method(D_METHOD("disconnect_peer", "id", "now"), &NetworkedMultiplayerENet::disconnect_peer, DEFVAL(false));
|
|
ClassDB::bind_method(D_METHOD("set_compression_mode", "mode"), &NetworkedMultiplayerENet::set_compression_mode);
|
|
ClassDB::bind_method(D_METHOD("get_compression_mode"), &NetworkedMultiplayerENet::get_compression_mode);
|
|
ClassDB::bind_method(D_METHOD("set_bind_ip", "ip"), &NetworkedMultiplayerENet::set_bind_ip);
|
|
ClassDB::bind_method(D_METHOD("get_peer_address", "id"), &NetworkedMultiplayerENet::get_peer_address);
|
|
ClassDB::bind_method(D_METHOD("get_peer_port", "id"), &NetworkedMultiplayerENet::get_peer_port);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_packet_channel"), &NetworkedMultiplayerENet::get_packet_channel);
|
|
ClassDB::bind_method(D_METHOD("get_last_packet_channel"), &NetworkedMultiplayerENet::get_last_packet_channel);
|
|
ClassDB::bind_method(D_METHOD("set_transfer_channel", "channel"), &NetworkedMultiplayerENet::set_transfer_channel);
|
|
ClassDB::bind_method(D_METHOD("get_transfer_channel"), &NetworkedMultiplayerENet::get_transfer_channel);
|
|
ClassDB::bind_method(D_METHOD("set_channel_count", "channels"), &NetworkedMultiplayerENet::set_channel_count);
|
|
ClassDB::bind_method(D_METHOD("get_channel_count"), &NetworkedMultiplayerENet::get_channel_count);
|
|
ClassDB::bind_method(D_METHOD("set_always_ordered", "ordered"), &NetworkedMultiplayerENet::set_always_ordered);
|
|
ClassDB::bind_method(D_METHOD("is_always_ordered"), &NetworkedMultiplayerENet::is_always_ordered);
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "compression_mode", PROPERTY_HINT_ENUM, "None,Range Coder,FastLZ,ZLib,ZStd"), "set_compression_mode", "get_compression_mode");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "transfer_channel"), "set_transfer_channel", "get_transfer_channel");
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "channel_count"), "set_channel_count", "get_channel_count");
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "always_ordered"), "set_always_ordered", "is_always_ordered");
|
|
|
|
BIND_ENUM_CONSTANT(COMPRESS_NONE);
|
|
BIND_ENUM_CONSTANT(COMPRESS_RANGE_CODER);
|
|
BIND_ENUM_CONSTANT(COMPRESS_FASTLZ);
|
|
BIND_ENUM_CONSTANT(COMPRESS_ZLIB);
|
|
BIND_ENUM_CONSTANT(COMPRESS_ZSTD);
|
|
}
|
|
|
|
NetworkedMultiplayerENet::NetworkedMultiplayerENet() {
|
|
|
|
active = false;
|
|
server = false;
|
|
refuse_connections = false;
|
|
unique_id = 0;
|
|
target_peer = 0;
|
|
current_packet.packet = NULL;
|
|
transfer_mode = TRANSFER_MODE_RELIABLE;
|
|
channel_count = SYSCH_MAX;
|
|
transfer_channel = -1;
|
|
always_ordered = false;
|
|
connection_status = CONNECTION_DISCONNECTED;
|
|
compression_mode = COMPRESS_NONE;
|
|
enet_compressor.context = this;
|
|
enet_compressor.compress = enet_compress;
|
|
enet_compressor.decompress = enet_decompress;
|
|
enet_compressor.destroy = enet_compressor_destroy;
|
|
|
|
bind_ip = IP_Address("*");
|
|
}
|
|
|
|
NetworkedMultiplayerENet::~NetworkedMultiplayerENet() {
|
|
|
|
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 NetworkedMultiplayerENet::set_bind_ip(const IP_Address &p_ip) {
|
|
ERR_FAIL_COND(!p_ip.is_valid() && !p_ip.is_wildcard());
|
|
|
|
bind_ip = p_ip;
|
|
}
|