2016-10-10 17:50:51 +00:00
/*************************************************************************/
2021-07-12 14:18:43 +00:00
/* enet_multiplayer_peer.cpp */
2016-10-10 17:50:51 +00:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
2016-10-10 17:50:51 +00:00
/*************************************************************************/
2022-01-03 20:27:34 +00:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
2016-10-10 17:50:51 +00:00
/* */
/* 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. */
/*************************************************************************/
2018-01-04 23:50:27 +00:00
2021-07-12 14:18:43 +00:00
# include "enet_multiplayer_peer.h"
2018-09-11 16:13:45 +00:00
# include "core/io/ip.h"
# include "core/io/marshalls.h"
# include "core/os/os.h"
2016-08-14 16:29:25 +00:00
2021-07-12 14:18:43 +00:00
void ENetMultiplayerPeer : : set_target_peer ( int p_peer ) {
2016-08-14 16:29:25 +00:00
target_peer = p_peer ;
}
2021-07-12 14:18:43 +00:00
int ENetMultiplayerPeer : : get_packet_peer ( ) const {
2021-07-15 23:48:44 +00:00
ERR_FAIL_COND_V_MSG ( ! _is_active ( ) , 1 , " The multiplayer instance isn't currently active. " ) ;
2016-08-19 19:48:08 +00:00
ERR_FAIL_COND_V ( incoming_packets . size ( ) = = 0 , 1 ) ;
2016-08-14 16:29:25 +00:00
return incoming_packets . front ( ) - > get ( ) . from ;
}
2022-10-08 18:50:19 +00:00
MultiplayerPeer : : TransferMode ENetMultiplayerPeer : : get_packet_mode ( ) const {
ERR_FAIL_COND_V_MSG ( ! _is_active ( ) , TRANSFER_MODE_RELIABLE , " The multiplayer instance isn't currently active. " ) ;
ERR_FAIL_COND_V ( incoming_packets . size ( ) = = 0 , TRANSFER_MODE_RELIABLE ) ;
return incoming_packets . front ( ) - > get ( ) . transfer_mode ;
}
int ENetMultiplayerPeer : : get_packet_channel ( ) 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 ) ;
int ch = incoming_packets . front ( ) - > get ( ) . channel ;
if ( ch > = SYSCH_MAX ) { // First 2 channels are reserved.
return ch - SYSCH_MAX + 1 ;
}
return 0 ;
}
2021-07-15 23:48:44 +00:00
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. " ) ;
2021-09-07 21:04:52 +00:00
set_refuse_new_connections ( false ) ;
2021-07-15 23:48:44 +00:00
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 ;
2020-01-13 15:51:17 +00:00
}
2016-08-14 16:29:25 +00:00
2021-07-15 23:48:44 +00:00
active_mode = MODE_SERVER ;
2016-08-19 19:48:08 +00:00
unique_id = 1 ;
2016-08-14 17:06:51 +00:00
connection_status = CONNECTION_CONNECTED ;
2021-07-15 23:48:44 +00:00
hosts [ 0 ] = host ;
2016-08-14 16:29:25 +00:00
return OK ;
}
2018-05-06 22:28:59 +00:00
2021-07-15 23:48:44 +00:00
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. " ) ;
2021-09-07 21:04:52 +00:00
set_refuse_new_connections ( false ) ;
2021-07-15 23:48:44 +00:00
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 ) ;
2021-03-29 16:14:50 +00:00
} else {
2021-07-15 23:48:44 +00:00
err = host - > create_host ( 1 , 0 , p_in_bandwidth , p_out_bandwidth ) ;
2021-03-29 16:14:50 +00:00
}
2021-07-15 23:48:44 +00:00
if ( err ! = OK ) {
return err ;
2021-03-29 16:14:50 +00:00
}
2016-08-14 17:06:51 +00:00
2021-07-15 22:43:49 +00:00
unique_id = generate_unique_id ( ) ;
2016-08-19 19:48:08 +00:00
2021-07-15 23:48:44 +00:00
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. " ) ;
2016-08-14 17:06:51 +00:00
}
2021-07-15 23:48:44 +00:00
// Need to wait for CONNECT event.
2016-08-14 17:06:51 +00:00
connection_status = CONNECTION_CONNECTING ;
2021-07-15 23:48:44 +00:00
active_mode = MODE_CLIENT ;
peers [ 1 ] = peer ;
hosts [ 0 ] = host ;
2016-08-14 16:29:25 +00:00
return OK ;
}
2021-07-15 23:48:44 +00:00
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 ;
}
2016-08-14 16:29:25 +00:00
2021-07-15 23:48:44 +00:00
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 ) ;
Fix various typos
Found via ` codespell -q 3 -S ./thirdparty,*.po,./DONORS.md -L ackward,ang,ans,ba,beng,cas,childs,childrens,dof,doubleclick,expct,fave,findn,gird,hist,inout,leapyear,lod,nd,numer,ois,ony,paket,seeked,sinc,switchs,te,uint,varn`
Update editor/import/resource_importer_layered_texture.cpp
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Update doc/classes/TileSetScenesCollectionSource.xml
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Update scene/gui/graph_edit.cpp
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Update scene/resources/animation.cpp
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Update scene/resources/animation.cpp
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Update scene/resources/animation.cpp
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Update scene/gui/rich_text_label.cpp
Co-authored-by: Raul Santos <raulsntos@gmail.com>
Revert previously committed change
2022-01-02 06:03:58 +00:00
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 exactly one peer in the connected state. " ) ;
2021-07-15 23:48:44 +00:00
hosts [ p_id ] = p_host ;
peers [ p_id ] = host_peers [ 0 ] ;
emit_signal ( SNAME ( " peer_connected " ) , p_id ) ;
return OK ;
}
2016-08-14 16:29:25 +00:00
2022-10-08 18:50:19 +00:00
void ENetMultiplayerPeer : : _store_packet ( int32_t p_source , ENetConnection : : Event & p_event ) {
Packet packet ;
packet . packet = p_event . packet ;
packet . channel = p_event . channel_id ;
packet . from = p_source ;
if ( p_event . packet - > flags & ENET_PACKET_FLAG_RELIABLE ) {
packet . transfer_mode = TRANSFER_MODE_RELIABLE ;
} else if ( p_event . packet - > flags & ENET_PACKET_FLAG_UNSEQUENCED ) {
packet . transfer_mode = TRANSFER_MODE_UNRELIABLE ;
} else {
packet . transfer_mode = TRANSFER_MODE_UNRELIABLE_ORDERED ;
}
packet . packet - > referenceCount + + ;
incoming_packets . push_back ( packet ) ;
}
2021-09-27 09:07:00 +00:00
bool ENetMultiplayerPeer : : _parse_server_event ( ENetConnection : : EventType p_type , ENetConnection : : Event & p_event ) {
switch ( p_type ) {
2021-07-15 23:48:44 +00:00
case ENetConnection : : EVENT_CONNECT : {
2021-09-07 21:04:52 +00:00
if ( is_refusing_new_connections ( ) ) {
2021-09-27 09:07:00 +00:00
p_event . peer - > reset ( ) ;
2021-07-15 23:48:44 +00:00
return false ;
}
// Client joined with invalid ID, probably trying to exploit us.
2021-09-27 09:07:00 +00:00
if ( p_event . data < 2 | | peers . has ( ( int ) p_event . data ) ) {
p_event . peer - > reset ( ) ;
2021-07-15 23:48:44 +00:00
return false ;
}
2021-09-27 09:07:00 +00:00
int id = p_event . data ;
p_event . peer - > set_meta ( SNAME ( " _net_id " ) , id ) ;
peers [ id ] = p_event . peer ;
2016-08-19 19:48:08 +00:00
2021-07-15 23:48:44 +00:00
emit_signal ( SNAME ( " peer_connected " ) , id ) ;
return false ;
}
case ENetConnection : : EVENT_DISCONNECT : {
2021-09-27 09:07:00 +00:00
int id = p_event . peer - > get_meta ( SNAME ( " _net_id " ) ) ;
2021-07-15 23:48:44 +00:00
if ( ! peers . has ( id ) ) {
// Never fully connected.
return false ;
}
2016-08-19 19:48:08 +00:00
2021-07-15 23:48:44 +00:00
emit_signal ( SNAME ( " peer_disconnected " ) , id ) ;
peers . erase ( id ) ;
return false ;
2016-08-19 19:48:08 +00:00
}
2021-07-15 23:48:44 +00:00
case ENetConnection : : EVENT_RECEIVE : {
2022-10-08 18:50:19 +00:00
int32_t source = p_event . peer - > get_meta ( SNAME ( " _net_id " ) ) ;
_store_packet ( source , p_event ) ;
2021-07-15 23:48:44 +00:00
return false ;
}
default :
return true ;
}
}
2016-08-19 19:48:08 +00:00
2021-09-27 09:07:00 +00:00
bool ENetMultiplayerPeer : : _parse_client_event ( ENetConnection : : EventType p_type , ENetConnection : : Event & p_event ) {
switch ( p_type ) {
2021-07-15 23:48:44 +00:00
case ENetConnection : : EVENT_CONNECT : {
connection_status = CONNECTION_CONNECTED ;
2021-08-06 00:00:56 +00:00
emit_signal ( SNAME ( " peer_connected " ) , 1 ) ;
2021-07-15 23:48:44 +00:00
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 : {
2022-10-08 18:50:19 +00:00
_store_packet ( 1 , p_event ) ;
2021-07-15 23:48:44 +00:00
return false ;
}
default :
return true ;
}
}
2021-09-27 09:07:00 +00:00
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 ) ;
2021-07-15 23:48:44 +00:00
}
2021-09-27 09:07:00 +00:00
hosts . erase ( p_peer_id ) ;
return true ;
case ENetConnection : : EVENT_RECEIVE : {
2022-10-08 18:50:19 +00:00
_store_packet ( p_peer_id , p_event ) ;
2021-09-27 09:07:00 +00:00
return false ;
} break ;
default :
// Nothing to do
return true ;
2016-08-14 16:29:25 +00:00
}
}
2021-07-15 23:48:44 +00:00
void ENetMultiplayerPeer : : poll ( ) {
ERR_FAIL_COND_MSG ( ! _is_active ( ) , " The multiplayer instance isn't currently active. " ) ;
2016-08-14 21:49:50 +00:00
2021-07-15 23:48:44 +00:00
_pop_current_packet ( ) ;
2021-09-27 09:07:00 +00:00
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 " ) ) ;
2021-07-15 23:48:44 +00:00
}
2021-09-27 09:07:00 +00:00
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 ) ) {
2021-07-15 23:48:44 +00:00
return ;
}
2021-09-27 09:07:00 +00:00
} 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 ) ;
2021-07-15 23:48:44 +00:00
}
2021-09-27 09:07:00 +00:00
}
ENetConnection : : Event event ;
ENetConnection : : EventType ret = hosts [ 0 ] - > service ( 0 , event ) ;
if ( ret = = ENetConnection : : EVENT_ERROR ) {
2021-07-15 23:48:44 +00:00
return ;
2021-09-27 09:07:00 +00:00
}
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 ;
2021-07-15 23:48:44 +00:00
}
}
bool ENetMultiplayerPeer : : is_server ( ) const {
return active_mode = = MODE_SERVER ;
2016-08-14 21:49:50 +00:00
}
2022-10-08 18:50:19 +00:00
bool ENetMultiplayerPeer : : is_server_relay_supported ( ) const {
return active_mode = = MODE_SERVER | | active_mode = = MODE_CLIENT ;
}
2021-07-12 14:18:43 +00:00
void ENetMultiplayerPeer : : close_connection ( uint32_t wait_usec ) {
2021-09-02 13:21:09 +00:00
if ( ! _is_active ( ) ) {
return ;
}
2016-08-14 16:29:25 +00:00
_pop_current_packet ( ) ;
2016-08-19 19:48:08 +00:00
bool peers_disconnected = false ;
2021-07-15 23:48:44 +00:00
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 ) ;
2016-08-19 19:48:08 +00:00
peers_disconnected = true ;
}
}
if ( peers_disconnected ) {
2021-07-15 23:48:44 +00:00
for ( KeyValue < int , Ref < ENetConnection > > & E : hosts ) {
E . value - > flush ( ) ;
}
2018-05-06 22:28:59 +00:00
if ( wait_usec > 0 ) {
OS : : get_singleton ( ) - > delay_usec ( wait_usec ) ; // Wait for disconnection packets to send
}
2016-08-19 19:48:08 +00:00
}
2021-07-15 23:48:44 +00:00
active_mode = MODE_NONE ;
2016-08-14 16:29:25 +00:00
incoming_packets . clear ( ) ;
2021-07-15 23:48:44 +00:00
peers . clear ( ) ;
hosts . clear ( ) ;
unique_id = 0 ;
2016-08-14 17:06:51 +00:00
connection_status = CONNECTION_DISCONNECTED ;
2021-09-07 21:04:52 +00:00
set_refuse_new_connections ( false ) ;
2016-08-14 16:29:25 +00:00
}
2021-07-12 14:18:43 +00:00
int ENetMultiplayerPeer : : get_available_packet_count ( ) const {
2016-08-14 16:29:25 +00:00
return incoming_packets . size ( ) ;
}
2018-05-06 22:28:59 +00:00
2021-07-12 14:18:43 +00:00
Error ENetMultiplayerPeer : : get_packet ( const uint8_t * * r_buffer , int & r_buffer_size ) {
2020-02-02 22:34:47 +00:00
ERR_FAIL_COND_V_MSG ( incoming_packets . size ( ) = = 0 , ERR_UNAVAILABLE , " No incoming packets available. " ) ;
2016-08-14 16:29:25 +00:00
_pop_current_packet ( ) ;
current_packet = incoming_packets . front ( ) - > get ( ) ;
incoming_packets . pop_front ( ) ;
2022-10-08 18:50:19 +00:00
* r_buffer = ( const uint8_t * ) ( current_packet . packet - > data ) ;
r_buffer_size = current_packet . packet - > dataLength ;
2016-08-14 16:29:25 +00:00
return OK ;
}
2018-05-06 22:28:59 +00:00
2021-07-12 14:18:43 +00:00
Error ENetMultiplayerPeer : : put_packet ( const uint8_t * p_buffer , int p_buffer_size ) {
2021-07-15 23:48:44 +00:00
ERR_FAIL_COND_V_MSG ( ! _is_active ( ) , ERR_UNCONFIGURED , " The multiplayer instance isn't currently active. " ) ;
2020-02-02 22:34:47 +00:00
ERR_FAIL_COND_V_MSG ( connection_status ! = CONNECTION_CONNECTED , ERR_UNCONFIGURED , " The multiplayer instance isn't currently connected to any server or client. " ) ;
2021-07-15 23:48:44 +00:00
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 ) ;
2016-08-14 16:29:25 +00:00
int packet_flags = 0 ;
2016-09-29 23:23:54 +00:00
int channel = SYSCH_RELIABLE ;
2022-09-29 09:53:28 +00:00
int tr_channel = get_transfer_channel ( ) ;
if ( tr_channel > 0 ) {
channel = SYSCH_MAX + tr_channel - 1 ;
2021-07-27 10:06:48 +00:00
} else {
2021-09-07 21:04:52 +00:00
switch ( get_transfer_mode ( ) ) {
2022-07-12 21:12:42 +00:00
case TRANSFER_MODE_UNRELIABLE : {
2021-09-27 08:09:32 +00:00
packet_flags = ENET_PACKET_FLAG_UNSEQUENCED | ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT ;
2021-07-27 10:06:48 +00:00
channel = SYSCH_UNRELIABLE ;
} break ;
2022-07-12 21:12:42 +00:00
case TRANSFER_MODE_UNRELIABLE_ORDERED : {
2021-09-27 08:09:32 +00:00
packet_flags = ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT ;
2021-07-27 10:06:48 +00:00
channel = SYSCH_UNRELIABLE ;
} break ;
2022-07-12 21:12:42 +00:00
case TRANSFER_MODE_RELIABLE : {
2021-07-27 10:06:48 +00:00
packet_flags = ENET_PACKET_FLAG_RELIABLE ;
channel = SYSCH_RELIABLE ;
} break ;
}
2016-08-14 16:29:25 +00:00
}
2021-09-27 08:09:32 +00:00
# ifdef DEBUG_ENABLED
2022-10-08 18:50:19 +00:00
if ( ( packet_flags & ENET_PACKET_FLAG_UNRELIABLE_FRAGMENT ) & & p_buffer_size > 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 , ENET_HOST_DEFAULT_MTU ) ) ;
2021-09-27 08:09:32 +00:00
}
# endif
2022-10-08 18:50:19 +00:00
ENetPacket * packet = enet_packet_create ( nullptr , p_buffer_size , packet_flags ) ;
memcpy ( & packet - > data [ 0 ] , p_buffer , p_buffer_size ) ;
2016-08-19 19:48:08 +00:00
2021-07-15 23:48:44 +00:00
if ( is_server ( ) ) {
2016-08-19 19:48:08 +00:00
if ( target_peer = = 0 ) {
2021-07-15 23:48:44 +00:00
hosts [ 0 ] - > broadcast ( channel , packet ) ;
2016-08-19 19:48:08 +00:00
2021-07-15 23:48:44 +00:00
} else if ( target_peer < 0 ) {
// Send to all but one and make copies for sending.
2016-08-19 19:48:08 +00:00
int exclude = - target_peer ;
2021-07-15 23:48:44 +00:00
for ( KeyValue < int , Ref < ENetPacketPeer > > & E : peers ) {
if ( E . key = = exclude ) {
2016-08-19 19:48:08 +00:00
continue ;
2020-05-14 14:41:43 +00:00
}
2021-07-15 23:48:44 +00:00
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 ( ) ;
2016-08-14 16:29:25 +00:00
2021-07-15 23:48:44 +00:00
} 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 ( ) ;
2016-08-19 19:48:08 +00:00
2021-07-15 23:48:44 +00:00
} 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 ( ) ;
2016-08-19 19:48:08 +00:00
}
2021-07-15 23:48:44 +00:00
_destroy_unused ( packet ) ;
2016-08-19 19:48:08 +00:00
} else {
2021-07-15 23:48:44 +00:00
peers [ target_peer ] - > send ( channel , packet ) ;
ERR_FAIL_COND_V ( ! hosts . has ( target_peer ) , ERR_BUG ) ;
hosts [ target_peer ] - > flush ( ) ;
2016-08-19 19:48:08 +00:00
}
2016-08-14 16:29:25 +00:00
}
return OK ;
}
2021-07-12 14:18:43 +00:00
int ENetMultiplayerPeer : : get_max_packet_size ( ) const {
2018-04-08 20:45:14 +00:00
return 1 < < 24 ; // Anything is good
2016-08-14 16:29:25 +00:00
}
2021-07-12 14:18:43 +00:00
void ENetMultiplayerPeer : : _pop_current_packet ( ) {
2016-08-14 16:29:25 +00:00
if ( current_packet . packet ) {
2021-07-15 23:48:44 +00:00
current_packet . packet - > referenceCount - - ;
_destroy_unused ( current_packet . packet ) ;
2020-04-01 23:20:12 +00:00
current_packet . packet = nullptr ;
2016-08-19 19:48:08 +00:00
current_packet . from = 0 ;
2018-05-12 17:42:00 +00:00
current_packet . channel = - 1 ;
2016-08-14 16:29:25 +00:00
}
}
2021-07-12 14:18:43 +00:00
MultiplayerPeer : : ConnectionStatus ENetMultiplayerPeer : : get_connection_status ( ) const {
2016-08-14 17:06:51 +00:00
return connection_status ;
}
2021-07-12 14:18:43 +00:00
int ENetMultiplayerPeer : : get_unique_id ( ) const {
2021-07-15 23:48:44 +00:00
ERR_FAIL_COND_V_MSG ( ! _is_active ( ) , 0 , " The multiplayer instance isn't currently active. " ) ;
2016-08-19 19:48:08 +00:00
return unique_id ;
}
2021-09-07 21:04:52 +00:00
void ENetMultiplayerPeer : : set_refuse_new_connections ( bool p_enabled ) {
2020-07-13 17:14:27 +00:00
# ifdef GODOT_ENET
2021-07-15 23:48:44 +00:00
if ( _is_active ( ) ) {
for ( KeyValue < int , Ref < ENetConnection > > & E : hosts ) {
2021-09-07 21:04:52 +00:00
E . value - > refuse_new_connections ( p_enabled ) ;
2021-07-15 23:48:44 +00:00
}
2020-07-23 08:38:48 +00:00
}
2020-07-13 17:14:27 +00:00
# endif
2021-09-07 21:04:52 +00:00
MultiplayerPeer : : set_refuse_new_connections ( p_enabled ) ;
2016-08-19 19:48:08 +00:00
}
2021-07-15 23:48:44 +00:00
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 ] ;
}
2016-08-22 04:14:08 +00:00
2021-07-15 23:48:44 +00:00
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 ] ;
}
2016-08-22 04:14:08 +00:00
2021-07-15 23:48:44 +00:00
void ENetMultiplayerPeer : : _destroy_unused ( ENetPacket * p_packet ) {
if ( p_packet - > referenceCount = = 0 ) {
enet_packet_destroy ( p_packet ) ;
2016-08-22 04:14:08 +00:00
}
2021-07-15 23:48:44 +00:00
}
2016-08-22 04:14:08 +00:00
2021-07-12 14:18:43 +00:00
void ENetMultiplayerPeer : : _bind_methods ( ) {
2021-07-15 23:48:44 +00:00
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 ) ;
2021-07-12 14:18:43 +00:00
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 ) ;
2021-07-15 23:48:44 +00:00
ClassDB : : bind_method ( D_METHOD ( " get_host " ) , & ENetMultiplayerPeer : : get_host ) ;
ClassDB : : bind_method ( D_METHOD ( " get_peer " , " id " ) , & ENetMultiplayerPeer : : get_peer ) ;
2018-05-12 17:42:00 +00:00
2021-07-15 23:48:44 +00:00
ADD_PROPERTY ( PropertyInfo ( Variant : : OBJECT , " host " , PROPERTY_HINT_RESOURCE_TYPE , " ENetConnection " , PROPERTY_USAGE_NONE ) , " " , " get_host " ) ;
2016-08-14 17:06:51 +00:00
}
2021-07-12 14:18:43 +00:00
ENetMultiplayerPeer : : ENetMultiplayerPeer ( ) {
2021-05-06 00:48:18 +00:00
bind_ip = IPAddress ( " * " ) ;
2016-08-14 16:29:25 +00:00
}
2016-08-14 17:06:51 +00:00
2021-07-12 14:18:43 +00:00
ENetMultiplayerPeer : : ~ ENetMultiplayerPeer ( ) {
2021-07-15 23:48:44 +00:00
if ( _is_active ( ) ) {
2019-06-01 13:42:22 +00:00
close_connection ( ) ;
}
2016-08-14 16:29:25 +00:00
}
2016-08-27 11:41:34 +00:00
2018-05-06 22:28:59 +00:00
// Sets IP for ENet to bind when using create_server or create_client
2016-08-27 11:41:34 +00:00
// if no IP is set, then ENet bind to ENET_HOST_ANY
2021-07-12 14:18:43 +00:00
void ENetMultiplayerPeer : : set_bind_ip ( const IPAddress & p_ip ) {
2020-02-02 22:34:47 +00:00
ERR_FAIL_COND_MSG ( ! p_ip . is_valid ( ) & & ! p_ip . is_wildcard ( ) , vformat ( " Invalid bind IP address: %s " , String ( p_ip ) ) ) ;
2017-01-22 05:00:59 +00:00
bind_ip = p_ip ;
2016-08-27 11:41:34 +00:00
}