godot/modules/enet/networked_multiplayer_enet.cpp
Juan Linietsky 118eed485e ObjectTypeDB was renamed to ClassDB. Types are meant to be more generic to Variant.
All usages of "type" to refer to classes were renamed to "class"
ClassDB has been exposed to GDScript.
OBJ_TYPE() macro is now GDCLASS()
2017-01-02 23:03:46 -03:00

690 lines
19 KiB
C++

/*************************************************************************/
/* networked_multiplayer_enet.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* http://www.godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2017 Juan Linietsky, Ariel Manzur. */
/* */
/* 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 "os/os.h"
#include "io/marshalls.h"
#include "networked_multiplayer_enet.h"
void NetworkedMultiplayerENet::set_transfer_mode(TransferMode p_mode) {
transfer_mode=p_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;
}
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);
ENetAddress address;
address.host = bind_ip;
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 */,
SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */,
p_in_bandwidth /* assume any amount of incoming bandwidth */,
p_out_bandwidth /* assume any amount of outgoing bandwidth */);
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 IP_Address& p_ip, int p_port, int p_in_bandwidth, int p_out_bandwidth){
ERR_FAIL_COND_V(active,ERR_ALREADY_IN_USE);
ERR_FAIL_COND_V(!p_ip.is_ipv4(), ERR_INVALID_PARAMETER);
host = enet_host_create (NULL /* create a client host */,
1 /* only allow 1 outgoing connection */,
SYSCH_MAX /* allow up to SYSCH_MAX channels to be used */,
p_in_bandwidth /* 56K modem with 56 Kbps downstream bandwidth */,
p_out_bandwidth /* 56K modem with 14 Kbps upstream bandwidth */);
ERR_FAIL_COND_V(!host,ERR_CANT_CREATE);
_setup_compressor();
ENetAddress address;
address.host=*((uint32_t *)p_ip.get_ipv4());
address.port=p_port;
//enet_address_set_host (& address, "localhost");
//address.port = p_port;
unique_id=_gen_unique_id();
/* Initiate the connection, allocating the enough channels */
ENetPeer *peer = enet_host_connect (host, & address, SYSCH_MAX, 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;
/* Wait up to 1000 milliseconds for an event. */
while (true) {
if (!host || !active) //might have been disconnected while emitting a notification
return;
int ret = enet_host_service (host, & event, 1);
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;
}
IP_Address ip;
ip.set_ipv4((uint8_t *)&(event.peer -> address.host));
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 t something!
emit_signal("peer_connected",*new_id);
if (server) {
//someone connected, let it know of 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, let it know to everyone else
for (Map<int,ENetPeer*>::Element *E=peer_map.front();E;E=E->next()) {
if (E->key()==*id)
continue;
//send the new peer to existing peers
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 if (!server) {
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 < SYSCH_MAX){
Packet packet;
packet.packet = event.packet;
uint32_t *id = (uint32_t*)event.peer->data;
ERR_CONTINUE(event.packet->dataLength<12)
uint32_t source = decode_uint32(&event.packet->data[0]);
int target = decode_uint32(&event.packet->data[4]);
uint32_t flags = decode_uint32(&event.packet->data[8]);
packet.from=source;
if (server) {
// Someone is cheating and trying to fake the source!
ERR_CONTINUE(source!=*id);
packet.from=*id;
if (target==0) {
//re-send the 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,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,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() {
if (!active)
return;
_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);
OS::get_singleton()->delay_usec(100); //wait 100ms for disconnection packets to send
}
enet_host_destroy(host);
active=false;
incoming_packets.clear();
unique_id=1; //server is 1
connection_status=CONNECTION_DISCONNECTED;
}
int NetworkedMultiplayerENet::get_available_packet_count() const {
return incoming_packets.size();
}
Error NetworkedMultiplayerENet::get_packet(const uint8_t **r_buffer,int &r_buffer_size) const{
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*)(&current_packet.packet->data[12]);
r_buffer_size=current_packet.packet->dataLength-12;
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: {
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;
}
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+12,packet_flags);
encode_uint32(unique_id,&packet->data[0]); //source ID
encode_uint32(target_peer,&packet->data[4]); //dest ID
encode_uint32(packet_flags,&packet->data[8]); //dest ID
copymem(&packet->data[12],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() const {
if (current_packet.packet) {
enet_packet_destroy(current_packet.packet);
current_packet.packet=NULL;
current_packet.from=0;
}
}
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_data_dir().hash64(), hash );
//hash = hash_djb2_one_32(
// (uint32_t)OS::get_singleton()->get_unique_ID().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 negatie 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[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;
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.ptr(),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;
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: {
enet_host_compress(host,&enet_compressor);
} break;
}
}
void NetworkedMultiplayerENet::enet_compressor_destroy(void * context){
//do none
}
void NetworkedMultiplayerENet::_bind_methods() {
ClassDB::bind_method(_MD("create_server","port","max_clients","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_server,DEFVAL(32),DEFVAL(0),DEFVAL(0));
ClassDB::bind_method(_MD("create_client","ip","port","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_client,DEFVAL(0),DEFVAL(0));
ClassDB::bind_method(_MD("close_connection"),&NetworkedMultiplayerENet::close_connection);
ClassDB::bind_method(_MD("set_compression_mode","mode"),&NetworkedMultiplayerENet::set_compression_mode);
ClassDB::bind_method(_MD("get_compression_mode"),&NetworkedMultiplayerENet::get_compression_mode);
ClassDB::bind_method(_MD("set_bind_ip", "ip"),&NetworkedMultiplayerENet::set_bind_ip);
BIND_CONSTANT( COMPRESS_NONE );
BIND_CONSTANT( COMPRESS_RANGE_CODER );
BIND_CONSTANT( COMPRESS_FASTLZ );
BIND_CONSTANT( COMPRESS_ZLIB );
}
NetworkedMultiplayerENet::NetworkedMultiplayerENet(){
active=false;
server=false;
refuse_connections=false;
unique_id=0;
target_peer=0;
current_packet.packet=NULL;
transfer_mode=TRANSFER_MODE_RELIABLE;
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=ENET_HOST_ANY;
}
NetworkedMultiplayerENet::~NetworkedMultiplayerENet(){
close_connection();
}
// sets IP for ENet to bind when using create_server
// 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_ipv4());
bind_ip=*(uint32_t *)p_ip.get_ipv4();
}