659 lines
17 KiB
C++
659 lines
17 KiB
C++
#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);
|
|
|
|
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=p_ip.host;
|
|
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.host=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*)(¤t_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() {
|
|
|
|
ObjectTypeDB::bind_method(_MD("create_server","port","max_clients","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_server,DEFVAL(32),DEFVAL(0),DEFVAL(0));
|
|
ObjectTypeDB::bind_method(_MD("create_client","ip","port","in_bandwidth","out_bandwidth"),&NetworkedMultiplayerENet::create_client,DEFVAL(0),DEFVAL(0));
|
|
ObjectTypeDB::bind_method(_MD("close_connection"),&NetworkedMultiplayerENet::close_connection);
|
|
ObjectTypeDB::bind_method(_MD("set_compression_mode","mode"),&NetworkedMultiplayerENet::set_compression_mode);
|
|
ObjectTypeDB::bind_method(_MD("get_compression_mode"),&NetworkedMultiplayerENet::get_compression_mode);
|
|
ObjectTypeDB::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){
|
|
bind_ip=p_ip.host;
|
|
}
|