diff --git a/core/io/compression.cpp b/core/io/compression.cpp index a17e358cbb2..ca44d249116 100644 --- a/core/io/compression.cpp +++ b/core/io/compression.cpp @@ -60,6 +60,10 @@ int Compression::compress(uint8_t *p_dst, const uint8_t *p_src, int p_src_size,M strm.avail_in=p_src_size; int aout = deflateBound(&strm,p_src_size);; + /*if (aout>p_src_size) { + deflateEnd(&strm); + return -1; + }*/ strm.avail_out=aout; strm.next_in=(Bytef*)p_src; strm.next_out=p_dst; @@ -107,19 +111,21 @@ int Compression::get_max_compressed_buffer_size(int p_src_size,Mode p_mode){ -void Compression::decompress(uint8_t *p_dst, int p_dst_max_size, const uint8_t *p_src, int p_src_size,Mode p_mode){ +int Compression::decompress(uint8_t *p_dst, int p_dst_max_size, const uint8_t *p_src, int p_src_size,Mode p_mode){ switch(p_mode) { case MODE_FASTLZ: { + int ret_size=0; + if (p_dst_max_size<16) { uint8_t dst[16]; - fastlz_decompress(p_src,p_src_size,dst,16); + ret_size = fastlz_decompress(p_src,p_src_size,dst,16); copymem(p_dst,dst,p_dst_max_size); } else { - fastlz_decompress(p_src,p_src_size,p_dst,p_dst_max_size); + ret_size = fastlz_decompress(p_src,p_src_size,p_dst,p_dst_max_size); } - return; + return ret_size; } break; case MODE_DEFLATE: { @@ -130,7 +136,7 @@ void Compression::decompress(uint8_t *p_dst, int p_dst_max_size, const uint8_t * strm.avail_in= 0; strm.next_in=Z_NULL; int err = inflateInit(&strm); - ERR_FAIL_COND(err!=Z_OK); + ERR_FAIL_COND_V(err!=Z_OK,-1); strm.avail_in=p_src_size; strm.avail_out=p_dst_max_size; @@ -138,11 +144,12 @@ void Compression::decompress(uint8_t *p_dst, int p_dst_max_size, const uint8_t * strm.next_out=p_dst; err = inflate(&strm,Z_FINISH); + int total = strm.total_out; inflateEnd(&strm); - ERR_FAIL_COND(err!=Z_STREAM_END); - return; + ERR_FAIL_COND_V(err!=Z_STREAM_END,-1); + return total; } break; } - ERR_FAIL(); + ERR_FAIL_V(-1); } diff --git a/core/io/compression.h b/core/io/compression.h index 07a293c9403..e0a4d31a514 100644 --- a/core/io/compression.h +++ b/core/io/compression.h @@ -43,7 +43,7 @@ public: static int compress(uint8_t *p_dst, const uint8_t *p_src, int p_src_size,Mode p_mode=MODE_FASTLZ); static int get_max_compressed_buffer_size(int p_src_size,Mode p_mode=MODE_FASTLZ); - static void decompress(uint8_t *p_dst, int p_dst_max_size, const uint8_t *p_src, int p_src_size,Mode p_mode=MODE_FASTLZ); + static int decompress(uint8_t *p_dst, int p_dst_max_size, const uint8_t *p_src, int p_src_size,Mode p_mode=MODE_FASTLZ); Compression(); }; diff --git a/core/io/stream_peer.cpp b/core/io/stream_peer.cpp index 306e7d8c9d1..176d55ffdda 100644 --- a/core/io/stream_peer.cpp +++ b/core/io/stream_peer.cpp @@ -222,6 +222,7 @@ void StreamPeer::put_double(double p_val){ void StreamPeer::put_utf8_string(const String& p_string) { CharString cs=p_string.utf8(); + put_u32(p_string.length()); put_data((const uint8_t*)cs.get_data(),cs.length()); } @@ -348,8 +349,10 @@ String StreamPeer::get_string(int p_bytes){ ERR_FAIL_COND_V(p_bytes<0,String()); Vector buf; - buf.resize(p_bytes+1); - get_data((uint8_t*)&buf[0],p_bytes); + Error err = buf.resize(p_bytes+1); + ERR_FAIL_COND_V(err!=OK,String()); + err = get_data((uint8_t*)&buf[0],p_bytes); + ERR_FAIL_COND_V(err!=OK,String()); buf[p_bytes]=0; return buf.ptr(); @@ -359,8 +362,10 @@ String StreamPeer::get_utf8_string(int p_bytes){ ERR_FAIL_COND_V(p_bytes<0,String()); Vector buf; - buf.resize(p_bytes); - get_data(buf.ptr(),p_bytes); + Error err = buf.resize(p_bytes); + ERR_FAIL_COND_V(err!=OK,String()); + err = get_data(buf.ptr(),p_bytes); + ERR_FAIL_COND_V(err!=OK,String()); String ret; ret.parse_utf8((const char*)buf.ptr(),buf.size()); @@ -371,8 +376,10 @@ Variant StreamPeer::get_var(){ int len = get_32(); Vector var; - var.resize(len); - get_data(var.ptr(),len); + Error err = var.resize(len); + ERR_FAIL_COND_V(err!=OK,Variant()); + err = get_data(var.ptr(),len); + ERR_FAIL_COND_V(err!=OK,Variant()); Variant ret; decode_variant(ret,var.ptr(),len); @@ -420,3 +427,127 @@ void StreamPeer::_bind_methods() { ObjectTypeDB::bind_method(_MD("get_utf8_string","bytes"),&StreamPeer::get_utf8_string); ObjectTypeDB::bind_method(_MD("get_var:Variant"),&StreamPeer::get_var); } +//////////////////////////////// + + +void StreamPeerBuffer::_bind_methods() { + + ObjectTypeDB::bind_method(_MD("seek","pos"),&StreamPeerBuffer::seek); + ObjectTypeDB::bind_method(_MD("get_size"),&StreamPeerBuffer::get_size); + ObjectTypeDB::bind_method(_MD("get_pos"),&StreamPeerBuffer::get_pos); + ObjectTypeDB::bind_method(_MD("resize","size"),&StreamPeerBuffer::resize); + ObjectTypeDB::bind_method(_MD("set_data_array","data"),&StreamPeerBuffer::set_data_array); + ObjectTypeDB::bind_method(_MD("get_data_array"),&StreamPeerBuffer::get_data_array); + ObjectTypeDB::bind_method(_MD("clear"),&StreamPeerBuffer::clear); + ObjectTypeDB::bind_method(_MD("duplicate:StreamPeerBuffer"),&StreamPeerBuffer::duplicate); + +} + + +Error StreamPeerBuffer::put_data(const uint8_t* p_data,int p_bytes) { + + if (p_bytes<=0) + return OK; + + if (pointer+p_bytes > data.size()) { + data.resize(pointer+p_bytes); + + } + + DVector::Write w = data.write(); + copymem(&w[pointer],p_data,p_bytes); + + pointer+=p_bytes; + return OK; +} + +Error StreamPeerBuffer::put_partial_data(const uint8_t* p_data,int p_bytes, int &r_sent){ + + r_sent=p_bytes; + return put_data(p_data,p_bytes); +} + +Error StreamPeerBuffer::get_data(uint8_t* p_buffer, int p_bytes){ + + int recv; + get_partial_data(p_buffer,p_bytes,recv); + if (recv!=p_bytes) + return ERR_INVALID_PARAMETER; + + return OK; + +} +Error StreamPeerBuffer::get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_received){ + + + if (pointer+p_bytes > data.size()) { + r_received=data.size()-pointer; + if (r_received<=0) { + r_received=0; + return OK; //you got 0 + } + } else { + r_received=p_bytes; + } + + DVector::Read r = data.read(); + copymem(p_buffer,r.ptr(),r_received); +} + +int StreamPeerBuffer::get_available_bytes() const { + + return data.size()-pointer; +} + +void StreamPeerBuffer::seek(int p_pos){ + + ERR_FAIL_COND(p_pos < 0); + ERR_FAIL_COND(p_pos > data.size()); + pointer=p_pos; +} +int StreamPeerBuffer::get_size() const{ + + return data.size(); +} + +int StreamPeerBuffer::get_pos() const { + + return pointer; +} + +void StreamPeerBuffer::resize(int p_size){ + + data.resize(p_size); +} + +void StreamPeerBuffer::set_data_array(const DVector & p_data){ + + data=p_data; + pointer=0; +} + +DVector StreamPeerBuffer::get_data_array() const{ + + return data; +} + + +void StreamPeerBuffer::clear() { + + data.resize(0); + pointer=0; +} + + +Ref StreamPeerBuffer::duplicate() const { + + Ref spb; + spb.instance(); + spb->data=data; +} + + +StreamPeerBuffer::StreamPeerBuffer() { + + pointer=0; +} diff --git a/core/io/stream_peer.h b/core/io/stream_peer.h index 970e6695a56..f28e6f594d7 100644 --- a/core/io/stream_peer.h +++ b/core/io/stream_peer.h @@ -91,4 +91,40 @@ public: StreamPeer() { big_endian=false; } }; + +class StreamPeerBuffer : public StreamPeer { + + OBJ_TYPE(StreamPeerBuffer,StreamPeer); + + DVector data; + int pointer; +protected: + + static void _bind_methods(); +public: + Error put_data(const uint8_t* p_data,int p_bytes); + Error put_partial_data(const uint8_t* p_data,int p_bytes, int &r_sent); + + Error get_data(uint8_t* p_buffer, int p_bytes); + Error get_partial_data(uint8_t* p_buffer, int p_bytes,int &r_received); + + virtual int get_available_bytes() const; + + void seek(int p_pos); + int get_size() const; + int get_pos() const; + void resize(int p_size); + + + void set_data_array(const DVector & p_data); + DVector get_data_array() const; + + void clear(); + + Ref duplicate() const; + + StreamPeerBuffer(); +}; + + #endif // STREAM_PEER_H diff --git a/core/path_db.cpp b/core/path_db.cpp index d0feda5c82a..132cc83a353 100644 --- a/core/path_db.cpp +++ b/core/path_db.cpp @@ -363,6 +363,7 @@ NodePath::NodePath(const String& p_path) { from=i+1; } + } path=path.substr(0,subpath_pos); @@ -380,6 +381,8 @@ NodePath::NodePath(const String& p_path) { last_is_slash=false; } + + } if (slices==0 && !absolute && !property) @@ -413,6 +416,7 @@ NodePath::NodePath(const String& p_path) { } else { last_is_slash=false; } + } diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp index 97bd5f2a327..3de26573f40 100644 --- a/core/register_core_types.cpp +++ b/core/register_core_types.cpp @@ -118,6 +118,7 @@ void register_core_types() { ObjectTypeDB::register_type(); ObjectTypeDB::register_type(); ObjectTypeDB::register_virtual_type(); + ObjectTypeDB::register_type(); ObjectTypeDB::register_create_type(); ObjectTypeDB::register_create_type(); ObjectTypeDB::register_create_type(); diff --git a/core/string_db.cpp b/core/string_db.cpp index 9a693f88e9b..bf92c4eac45 100644 --- a/core/string_db.cpp +++ b/core/string_db.cpp @@ -183,7 +183,8 @@ StringName::StringName(const char *p_name) { ERR_FAIL_COND(!configured); - ERR_FAIL_COND( !p_name || !p_name[0]); + if (!p_name || p_name[0]==0) + return; //empty, ignore _global_lock(); @@ -288,6 +289,9 @@ StringName::StringName(const String& p_name) { ERR_FAIL_COND(!configured); + if (p_name==String()) + return; + _global_lock(); uint32_t hash = p_name.hash(); diff --git a/modules/enet/networked_multiplayer_enet.cpp b/modules/enet/networked_multiplayer_enet.cpp index dd83a1ac5db..5ddbb835344 100644 --- a/modules/enet/networked_multiplayer_enet.cpp +++ b/modules/enet/networked_multiplayer_enet.cpp @@ -38,6 +38,7 @@ Error NetworkedMultiplayerENet::create_server(int p_port, int p_max_clients, int ERR_FAIL_COND_V(!host,ERR_CANT_CREATE); + _setup_compressor(); active=true; server=true; refuse_connections=false; @@ -58,6 +59,8 @@ Error NetworkedMultiplayerENet::create_client(const IP_Address& p_ip, int p_port ERR_FAIL_COND_V(!host,ERR_CANT_CREATE); + _setup_compressor(); + ENetAddress address; address.host=p_ip.host; address.port=p_port; @@ -494,13 +497,124 @@ 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())src_compressor_mem.resize( inLimit ); + } + + int total = inLimit; + int ofs=0; + while(total) { + for(size_t i=0;isrc_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()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); + BIND_CONSTANT( COMPRESS_NONE ); + BIND_CONSTANT( COMPRESS_RANGE_CODER ); + BIND_CONSTANT( COMPRESS_FASTLZ ); + BIND_CONSTANT( COMPRESS_ZLIB ); } @@ -515,6 +629,12 @@ NetworkedMultiplayerENet::NetworkedMultiplayerENet(){ 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; + } NetworkedMultiplayerENet::~NetworkedMultiplayerENet(){ diff --git a/modules/enet/networked_multiplayer_enet.h b/modules/enet/networked_multiplayer_enet.h index 235686d1437..dc86058cbb5 100644 --- a/modules/enet/networked_multiplayer_enet.h +++ b/modules/enet/networked_multiplayer_enet.h @@ -3,10 +3,20 @@ #include "io/networked_multiplayer_peer.h" #include "enet/enet.h" +#include "io/compression.h" class NetworkedMultiplayerENet : public NetworkedMultiplayerPeer { OBJ_TYPE(NetworkedMultiplayerENet,NetworkedMultiplayerPeer) +public: + enum CompressionMode { + COMPRESS_NONE, + COMPRESS_RANGE_CODER, + COMPRESS_FASTLZ, + COMPRESS_ZLIB + }; +private: + enum { SYSMSG_ADD_PEER, @@ -37,6 +47,8 @@ class NetworkedMultiplayerENet : public NetworkedMultiplayerPeer { int from; }; + CompressionMode compression_mode; + mutable List incoming_packets; mutable Packet current_packet; @@ -44,6 +56,15 @@ class NetworkedMultiplayerENet : public NetworkedMultiplayerPeer { uint32_t _gen_unique_id() const; void _pop_current_packet() const; + Vector src_compressor_mem; + Vector dst_compressor_mem; + + ENetCompressor enet_compressor; + static size_t enet_compress(void * context, const ENetBuffer * inBuffers, size_t inBufferCount, size_t inLimit, enet_uint8 * outData, size_t outLimit); + static size_t enet_decompress (void * context, const enet_uint8 * inData, size_t inLimit, enet_uint8 * outData, size_t outLimit); + static void enet_compressor_destroy(void * context); + void _setup_compressor(); + protected: static void _bind_methods(); public: @@ -77,9 +98,14 @@ public: virtual int get_unique_id() const; + void set_compression_mode(CompressionMode p_mode); + CompressionMode get_compression_mode() const; + NetworkedMultiplayerENet(); ~NetworkedMultiplayerENet(); }; +VARIANT_ENUM_CAST(NetworkedMultiplayerENet::CompressionMode); + #endif // NETWORKED_MULTIPLAYER_ENET_H diff --git a/modules/enet/protocol.c b/modules/enet/protocol.c index 5225147942b..4a2a4ed185a 100644 --- a/modules/enet/protocol.c +++ b/modules/enet/protocol.c @@ -1692,7 +1692,7 @@ enet_protocol_send_outgoing_commands (ENetHost * host, ENetEvent * event, int ch & host -> buffers [1], host -> bufferCount - 1, originalSize, host -> packetData [1], - originalSize); + originalSize); if (compressedSize > 0 && compressedSize < originalSize) { host -> headerFlags |= ENET_PROTOCOL_HEADER_FLAG_COMPRESSED; diff --git a/scene/main/scene_main_loop.cpp b/scene/main/scene_main_loop.cpp index e161bd7334f..4c7b7c13992 100644 --- a/scene/main/scene_main_loop.cpp +++ b/scene/main/scene_main_loop.cpp @@ -44,7 +44,7 @@ #include "scene/resources/packed_scene.h" #include "scene/resources/material.h" #include "scene/resources/mesh.h" - +#include "io/marshalls.h" void SceneTreeTimer::_bind_methods() { @@ -1760,6 +1760,11 @@ void SceneTree::_rpc(Node* p_from,int p_to,bool p_unreliable,bool p_set,const St ERR_FAIL(); } + if (p_argcount>255) { + ERR_EXPLAIN("Too many arguments >255."); + ERR_FAIL(); + } + if (p_to!=0 && !connected_peers.has(ABS(p_to))) { if (p_to==get_network_unique_id()) { ERR_EXPLAIN("Attempt to remote call/set yourself! unique ID: "+itos(get_network_unique_id())); @@ -1774,25 +1779,7 @@ void SceneTree::_rpc(Node* p_from,int p_to,bool p_unreliable,bool p_set,const St NodePath from_path = p_from->get_path(); ERR_FAIL_COND(from_path.is_empty()); - //create base packet - Array message; - message.resize(3+p_argcount); //alloc size for args - - //set message type - if (p_set) { - message[0]=NETWORK_COMMAND_REMOTE_SET; - } else { - message[0]=NETWORK_COMMAND_REMOTE_CALL; - } - - //set message name - message[2]=p_name; - - //set message args - for(int i=0;iid,&packet_cache[ofs]); + ofs+=4; + + //encode function name + CharString name = String(p_name).utf8(); + int len = encode_cstring(name.get_data(),NULL); + MAKE_ROOM(ofs+len); + encode_cstring(name.get_data(),&packet_cache[ofs]); + ofs+=len; + + if (p_set) { + //set argument + Error err = encode_variant(*p_arg[0],NULL,len); + ERR_FAIL_COND(err!=OK); + MAKE_ROOM(ofs+len); + encode_variant(*p_arg[0],&packet_cache[ofs],len); + ofs+=len; + + } else { + //call arguments + MAKE_ROOM(ofs+1); + packet_cache[ofs]=p_argcount; + ofs+=1; + for(int i=0;i::Element *E=peers_to_add.front();E;E=E->next()) { - Array add_path_message; - add_path_message.resize(3); - add_path_message[0]=NETWORK_COMMAND_SIMPLIFY_PATH; - add_path_message[1]=from_path; - add_path_message[2]=psc->id; + //encode function name + CharString pname = String(from_path).utf8(); + int len = encode_cstring(pname.get_data(),NULL); + + Vector packet; + + packet.resize(1+4+len); + packet[0]=NETWORK_COMMAND_SIMPLIFY_PATH; + encode_uint32(psc->id,&packet[1]); + encode_cstring(pname.get_data(),&packet[5]); network_peer->set_target_peer(E->get()); //to all of you network_peer->set_transfer_mode(NetworkedMultiplayerPeer::TRANSFER_MODE_RELIABLE); - network_peer->put_var(add_path_message); //a message with love + network_peer->put_packet(packet.ptr(),packet.size()); psc->confirmed_peers.insert(E->get(),false); //insert into confirmed, but as false since it was not confirmed } @@ -1853,12 +1892,18 @@ void SceneTree::_rpc(Node* p_from,int p_to,bool p_unreliable,bool p_set,const St if (has_all_peers) { //they all have verified paths, so send fast - message[1]=psc->id; - network_peer->set_target_peer(p_to); //to all of you - network_peer->put_var(message); //a message with love + network_peer->put_packet(packet_cache.ptr(),ofs); //a message with love } else { //not all verified path, so send one by one + + //apend path at the end, since we will need it for some packets + CharString pname = String(from_path).utf8(); + int path_len = encode_cstring(pname.get_data(),NULL); + MAKE_ROOM(ofs+path_len); + encode_cstring(pname.get_data(),&packet_cache[ofs]); + + for (Set::Element *E=connected_peers.front();E;E=E->next()) { if (p_to<0 && E->get()==-p_to) @@ -1874,41 +1919,52 @@ void SceneTree::_rpc(Node* p_from,int p_to,bool p_unreliable,bool p_set,const St if (F->get()==true) { //this one confirmed path, so use id - message[1]=psc->id; + encode_uint32(psc->id,&packet_cache[1]); + network_peer->put_packet(packet_cache.ptr(),ofs); } else { //this one did not confirm path yet, so use entire path (sorry!) - message[1]=from_path; + encode_uint32(0x80000000|ofs,&packet_cache[1]); //offset to path and flag + network_peer->put_packet(packet_cache.ptr(),ofs+path_len); } - network_peer->put_var(message); } } } -void SceneTree::_network_process_packet(int p_from, const Array& p_packet) { +void SceneTree::_network_process_packet(int p_from, const uint8_t* p_packet, int p_packet_len) { - ERR_FAIL_COND(p_packet.empty()); + ERR_FAIL_COND(p_packet_len<5); - int packet_type = p_packet[0]; + uint8_t packet_type = p_packet[0]; switch(packet_type) { case NETWORK_COMMAND_REMOTE_CALL: case NETWORK_COMMAND_REMOTE_SET: { - ERR_FAIL_COND(p_packet.size()<3); - Variant target = p_packet[1]; - Node* node=NULL; + ERR_FAIL_COND(p_packet_len<5); + uint32_t target = decode_uint32(&p_packet[1]); + + + Node *node=NULL; + + if (target&0x80000000) { + + int ofs = target&0x7FFFFFFF; + ERR_FAIL_COND(ofs>=p_packet_len); + + String paths; + paths.parse_utf8((const char*)&p_packet[ofs],p_packet_len-ofs); + + NodePath np = paths; - if (target.get_type()==Variant::NODE_PATH) { - NodePath np = target; node = get_root()->get_node(np); if (node==NULL) { ERR_EXPLAIN("Failed to get path from RPC: "+String(np)); ERR_FAIL_COND(node==NULL); } - } else if (target.get_type()==Variant::INT) { + } else { int id = target; @@ -1928,26 +1984,51 @@ void SceneTree::_network_process_packet(int p_from, const Array& p_packet) { } - } else { - ERR_FAIL(); } - StringName name = p_packet[2]; + ERR_FAIL_COND(p_packet_len<6); + + //detect cstring end + int len_end=5; + for(;len_end=p_packet_len); + + StringName name = String::utf8((const char*)&p_packet[5]); + + + if (packet_type==NETWORK_COMMAND_REMOTE_CALL) { if (!node->can_call_rpc(name)) return; - int argc = p_packet.size()-3; + int ofs = len_end+1; + + ERR_FAIL_COND(ofs>=p_packet_len); + + int argc = p_packet[ofs]; Vector args; Vector argp; args.resize(argc); argp.resize(argc); + ofs++; + for(int i=0;i=p_packet_len); + int vlen; + Error err = decode_variant(args[i],&p_packet[ofs],p_packet_len-ofs,&vlen); + ERR_FAIL_COND(err!=OK); + //args[i]=p_packet[3+i]; + argp[i]=&args[i]; + ofs+=vlen; } Variant::CallError ce; @@ -1964,9 +2045,13 @@ void SceneTree::_network_process_packet(int p_from, const Array& p_packet) { if (!node->can_call_rset(name)) return; + int ofs = len_end+1; + + ERR_FAIL_COND(ofs>=p_packet_len); + + Variant value; + decode_variant(value,&p_packet[ofs],p_packet_len-ofs); - ERR_FAIL_COND(p_packet.size()!=4); - Variant value = p_packet[3]; bool valid; node->set(name,value,&valid); @@ -1979,9 +2064,13 @@ void SceneTree::_network_process_packet(int p_from, const Array& p_packet) { } break; case NETWORK_COMMAND_SIMPLIFY_PATH: { - ERR_FAIL_COND(p_packet.size()!=3); - NodePath path = p_packet[1]; - int id = p_packet[2]; + ERR_FAIL_COND(p_packet_len<5); + int id = decode_uint32(&p_packet[1]); + + String paths; + paths.parse_utf8((const char*)&p_packet[5],p_packet_len-5); + + NodePath path = paths; if (!path_get_cache.has(p_from)) { path_get_cache[p_from]=PathGetCache(); @@ -1993,19 +2082,31 @@ void SceneTree::_network_process_packet(int p_from, const Array& p_packet) { path_get_cache[p_from].nodes[id]=ni; - network_peer->set_transfer_mode(NetworkedMultiplayerPeer::TRANSFER_MODE_RELIABLE); - network_peer->set_target_peer(p_from); - Array message; - message.resize(2); - message[0]=NETWORK_COMMAND_CONFIRM_PATH; - message[1]=path; - network_peer->put_var(message); + { + //send ack + + //encode path + CharString pname = String(path).utf8(); + int len = encode_cstring(pname.get_data(),NULL); + + Vector packet; + + packet.resize(1+len); + packet[0]=NETWORK_COMMAND_CONFIRM_PATH; + encode_cstring(pname.get_data(),&packet[1]); + + network_peer->set_transfer_mode(NetworkedMultiplayerPeer::TRANSFER_MODE_RELIABLE); + network_peer->set_target_peer(p_from); + network_peer->put_packet(packet.ptr(),packet.size()); + } } break; case NETWORK_COMMAND_CONFIRM_PATH: { - ERR_FAIL_COND(p_packet.size()!=2); - NodePath path = p_packet[1]; + String paths; + paths.parse_utf8((const char*)&p_packet[1],p_packet_len-1); + + NodePath path = paths; PathSentCache *psc = path_send_cache.getptr(path); ERR_FAIL_COND(!psc); @@ -2031,17 +2132,15 @@ void SceneTree::_network_poll() { while(network_peer->get_available_packet_count()) { int sender = network_peer->get_packet_peer(); - Variant packet; - Error err = network_peer->get_var(packet); + const uint8_t *packet; + int len; + + Error err = network_peer->get_packet(&packet,len); if (err!=OK) { ERR_PRINT("Error getting packet!"); } - if (packet.get_type()!=Variant::ARRAY) { - ERR_PRINT("Error getting packet! (not an array)"); - } - - _network_process_packet(sender,packet); + _network_process_packet(sender,packet,len); if (!network_peer.is_valid()) { break; //it's also possible that a packet or RPC caused a disconnection, so also check here diff --git a/scene/main/scene_main_loop.h b/scene/main/scene_main_loop.h index 652a835fd55..1c0f88862c4 100644 --- a/scene/main/scene_main_loop.h +++ b/scene/main/scene_main_loop.h @@ -217,7 +217,9 @@ private: Map path_get_cache; - void _network_process_packet(int p_from, const Array& p_packet); + Vector packet_cache; + + void _network_process_packet(int p_from, const uint8_t *p_packet, int p_packet_len); void _network_poll(); static SceneTree *singleton;