diff --git a/raknet/RakClient.cpp b/raknet/RakClient.cpp index 6e53e22..700d31d 100644 --- a/raknet/RakClient.cpp +++ b/raknet/RakClient.cpp @@ -118,17 +118,17 @@ void RakClient::vftable_54() // TODO: RakClient::vftable_54() (saco 10034A70) (server L: 8069340) (bot W: 4032B0 L: 806CD3E) } -void RakClient::RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ) +void RakClient::RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ) { RakPeer::RegisterAsRemoteProcedureCall( uniqueID, functionPointer ); } -void RakClient::RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer ) +void RakClient::RegisterClassMemberRPC( char* uniqueID, void *functionPointer ) { RakPeer::RegisterClassMemberRPC( uniqueID, functionPointer ); } -void RakClient::UnregisterAsRemoteProcedureCall( unsigned char* uniqueID ) +void RakClient::UnregisterAsRemoteProcedureCall( char* uniqueID ) { RakPeer::UnregisterAsRemoteProcedureCall( uniqueID ); } diff --git a/raknet/RakClient.h b/raknet/RakClient.h index 4831e72..e820beb 100644 --- a/raknet/RakClient.h +++ b/raknet/RakClient.h @@ -40,19 +40,19 @@ public: /// Register a C or static member function as available for calling as a remote procedure call /// \param[in] uniqueID: A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions /// \param[in] functionPointer(...): The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered - void RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); + void RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); /// \ingroup RAKNET_RPC /// Register a C++ member function as available for calling as a remote procedure call. /// \param[in] uniqueID: A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC /// \param[in] functionPointer: The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall /// \sa ObjectMemberRPC.cpp - void RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer ); + void RegisterClassMemberRPC( char* uniqueID, void *functionPointer ); /// \ingroup RAKNET_RPC /// Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline /// \param[in] uniqueID A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameterpassed to RegisterAsRemoteProcedureCall - void UnregisterAsRemoteProcedureCall( unsigned char* uniqueID ); + void UnregisterAsRemoteProcedureCall( char* uniqueID ); void vftable_64(); void vftable_68(); diff --git a/raknet/RakClientInterface.h b/raknet/RakClientInterface.h index 103c4e9..46a77fe 100644 --- a/raknet/RakClientInterface.h +++ b/raknet/RakClientInterface.h @@ -35,19 +35,19 @@ public: /// Register a C or static member function as available for calling as a remote procedure call /// \param[in] uniqueID: A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions /// \param[in] functionPointer(...): The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered - virtual void RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) )=0; + virtual void RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) )=0; /// \ingroup RAKNET_RPC /// Register a C++ member function as available for calling as a remote procedure call. /// \param[in] uniqueID: A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC /// \param[in] functionPointer: The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall /// \sa ObjectMemberRPC.cpp - virtual void RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer )=0; + virtual void RegisterClassMemberRPC( char* uniqueID, void *functionPointer )=0; ///\ingroup RAKNET_RPC /// Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline /// \param[in] uniqueID A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameterpassed to RegisterAsRemoteProcedureCall - virtual void UnregisterAsRemoteProcedureCall( unsigned char* uniqueID )=0; + virtual void UnregisterAsRemoteProcedureCall( char* uniqueID )=0; virtual void vftable_64()=0; virtual void vftable_68()=0; diff --git a/raknet/RakPeer.cpp b/raknet/RakPeer.cpp index 500d7c9..88fa90c 100644 --- a/raknet/RakPeer.cpp +++ b/raknet/RakPeer.cpp @@ -148,20 +148,20 @@ void RakPeer::vftable_40() // This can be called whether the client is active or not, and registered functions stay registered unless unregistered with // UnregisterAsRemoteProcedureCall // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -void RakPeer::RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ) +void RakPeer::RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ) { if ( uniqueID == 0 || uniqueID[ 0 ] == 0 || functionPointer == 0 ) return; - rpcMap.AddIdentifierWithFunction(*uniqueID, (void*)functionPointer, false); + rpcMap.AddIdentifierWithFunction((unsigned char)*uniqueID, (void*)functionPointer, false); } -void RakPeer::RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer ) +void RakPeer::RegisterClassMemberRPC( char* uniqueID, void *functionPointer ) { if ( uniqueID == 0 || uniqueID[ 0 ] == 0 || functionPointer == 0 ) return; - rpcMap.AddIdentifierWithFunction(*uniqueID, functionPointer, true); + rpcMap.AddIdentifierWithFunction((unsigned char)*uniqueID, functionPointer, true); } // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- @@ -173,7 +173,7 @@ void RakPeer::RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPoi // uniqueID: A null terminated string to identify this procedure. Must match the parameter // passed to RegisterAsRemoteProcedureCall // -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- -void RakPeer::UnregisterAsRemoteProcedureCall( unsigned char* uniqueID ) +void RakPeer::UnregisterAsRemoteProcedureCall( char* uniqueID ) { // nothing } diff --git a/raknet/RakPeer.h b/raknet/RakPeer.h index 90ee531..5ccbad5 100644 --- a/raknet/RakPeer.h +++ b/raknet/RakPeer.h @@ -57,19 +57,19 @@ public: /// Register a C or static member function as available for calling as a remote procedure call /// \param[in] uniqueID A null-terminated unique string to identify this procedure. See RegisterClassMemberRPC() for class member functions. /// \param[in] functionPointer(...) The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered - void RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); + void RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); /// \ingroup RAKNET_RPC /// Register a C++ member function as available for calling as a remote procedure call. /// \param[in] uniqueID A null terminated string to identify this procedure. Recommended you use the macro REGISTER_CLASS_MEMBER_RPC to create the string. Use RegisterAsRemoteProcedureCall() for static functions. /// \param[in] functionPointer The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall /// \sa The sample ObjectMemberRPC.cpp - void RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer ); + void RegisterClassMemberRPC( char* uniqueID, void *functionPointer ); /// \ingroup RAKNET_RPC /// Unregisters a C function as available for calling as a remote procedure call that was formerly registered with RegisterAsRemoteProcedureCall. Only call offline. /// \param[in] uniqueID A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. - void UnregisterAsRemoteProcedureCall( unsigned char* uniqueID ); + void UnregisterAsRemoteProcedureCall( char* uniqueID ); void vftable_50(); void vftable_54(); diff --git a/raknet/RakPeerInterface.h b/raknet/RakPeerInterface.h index 9f8c480..8ea107d 100644 --- a/raknet/RakPeerInterface.h +++ b/raknet/RakPeerInterface.h @@ -54,19 +54,19 @@ public: /// Register a C or static member function as available for calling as a remote procedure call /// \param[in] uniqueID A null-terminated unique string to identify this procedure. See RegisterClassMemberRPC() for class member functions. /// \param[in] functionPointer(...) The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered - virtual void RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) )=0; + virtual void RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) )=0; /// \ingroup RAKNET_RPC /// Register a C++ member function as available for calling as a remote procedure call. /// \param[in] uniqueID A null terminated string to identify this procedure. Recommended you use the macro REGISTER_CLASS_MEMBER_RPC to create the string. Use RegisterAsRemoteProcedureCall() for static functions. /// \param[in] functionPointer The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall /// \sa The sample ObjectMemberRPC.cpp - virtual void RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer )=0; + virtual void RegisterClassMemberRPC( char* uniqueID, void *functionPointer )=0; /// \ingroup RAKNET_RPC /// Unregisters a C function as available for calling as a remote procedure call that was formerly registered with RegisterAsRemoteProcedureCall. Only call offline. /// \param[in] uniqueID A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. - virtual void UnregisterAsRemoteProcedureCall( unsigned char* uniqueID )=0; + virtual void UnregisterAsRemoteProcedureCall( char* uniqueID )=0; virtual void vftable_50()=0; virtual void vftable_54()=0; diff --git a/raknet/RakServer.cpp b/raknet/RakServer.cpp index 3655f88..71f8efa 100644 --- a/raknet/RakServer.cpp +++ b/raknet/RakServer.cpp @@ -147,17 +147,17 @@ void RakServer::vftable_70() // TODO: RakServer::vftable_70() (server W: 45A450 L: 807C060) } -void RakServer::RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ) +void RakServer::RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ) { RakPeer::RegisterAsRemoteProcedureCall( uniqueID, functionPointer ); } -void RakServer::RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer ) +void RakServer::RegisterClassMemberRPC( char* uniqueID, void *functionPointer ) { RakPeer::RegisterClassMemberRPC( uniqueID, functionPointer ); } -void RakServer::UnregisterAsRemoteProcedureCall( unsigned char* uniqueID ) +void RakServer::UnregisterAsRemoteProcedureCall( char* uniqueID ) { RakPeer::UnregisterAsRemoteProcedureCall( uniqueID ); } diff --git a/raknet/RakServer.h b/raknet/RakServer.h index 0d4a310..0eb0ea7 100644 --- a/raknet/RakServer.h +++ b/raknet/RakServer.h @@ -59,19 +59,19 @@ public: /// Register a C or static member function as available for calling as a remote procedure call /// \param[in] uniqueID: A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions /// \param[in] functionPointer The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered - void RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); + void RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) ); /// \ingroup RAKNET_RPC /// Register a C++ member function as available for calling as a remote procedure call. /// \param[in] uniqueID: A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC /// \param[in] functionPointer: The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall /// \sa ObjectMemberRPC.cpp - void RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer ); + void RegisterClassMemberRPC( char* uniqueID, void *functionPointer ); ///\ingroup RAKNET_RPC /// Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline /// \param[in] uniqueID A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameterpassed to RegisterAsRemoteProcedureCall - void UnregisterAsRemoteProcedureCall( unsigned char* uniqueID ); + void UnregisterAsRemoteProcedureCall( char* uniqueID ); void vftable_80(); void vftable_84(); diff --git a/raknet/RakServerInterface.h b/raknet/RakServerInterface.h index fd97e5f..82f3c63 100644 --- a/raknet/RakServerInterface.h +++ b/raknet/RakServerInterface.h @@ -56,19 +56,19 @@ public: /// Register a C or static member function as available for calling as a remote procedure call /// \param[in] uniqueID: A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions /// \param[in] functionPointer The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered - virtual void RegisterAsRemoteProcedureCall( unsigned char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) )=0; + virtual void RegisterAsRemoteProcedureCall( char* uniqueID, void ( *functionPointer ) ( RPCParameters *rpcParms ) )=0; /// \ingroup RAKNET_RPC /// Register a C++ member function as available for calling as a remote procedure call. /// \param[in] uniqueID: A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC /// \param[in] functionPointer: The name of the function to be used as a function pointer. This can be called whether active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall /// \sa ObjectMemberRPC.cpp - virtual void RegisterClassMemberRPC( unsigned char* uniqueID, void *functionPointer )=0; + virtual void RegisterClassMemberRPC( char* uniqueID, void *functionPointer )=0; ///\ingroup RAKNET_RPC /// Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline /// \param[in] uniqueID A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameterpassed to RegisterAsRemoteProcedureCall - virtual void UnregisterAsRemoteProcedureCall( unsigned char* uniqueID )=0; + virtual void UnregisterAsRemoteProcedureCall( char* uniqueID )=0; virtual void vftable_80()=0; virtual void vftable_84()=0;