- Main Page
- Modules
- Namespaces
- Classes
- Files
- Directories
- Related Pages

# Remote Procedure Call Subsystem

A system to call C or object member procudures on other systems, and even to return return values. More...

## Files
file | RPCMap.h
| [Internal] A container class for a list of RPCNodes

file | RPCNode.h
| [Internal] Holds information related to a RPC

## Classes
struct | RPCMap
struct | RPCNode
## Defines
#define | REGISTER_STATIC_RPC(networkObject, functionName) (networkObject)->RegisterAsRemoteProcedureCall((#functionName),(functionName))
| RPC Function Implementation.
#define | CLASS_MEMBER_ID(className, functionName) #className "_" #functionName
| Concatenate two strings.
#define | REGISTER_CLASS_MEMBER_RPC(networkObject, className, functionName) {union {void (__cdecl className::*cFunc)( RPCParameters *rpcParms ); void* voidFunc;}; cFunc=&className::functionName; networkObject->RegisterClassMemberRPC(CLASS_MEMBER_ID(className, functionName),voidFunc);}
| Register a member function of an instantiated object as a Remote procedure call. RPC member Functions MUST be marked __cdecl!
#define | UNREGISTER_STATIC_RPC(networkObject, functionName) (networkObject)->UnregisterAsRemoteProcedureCall((#functionName))
## Functions
void | RakClient::RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms))
void | RakClient::RegisterClassMemberRPC (char *uniqueID, void *functionPointer)
void | RakClient::UnregisterAsRemoteProcedureCall (char *uniqueID)
bool | RakClient::RPC (char *uniqueID, const char *data, unsigned int bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)
bool | RakClient::RPC (char *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)
virtual void | RakClientInterface::RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms))=0
virtual void | RakClientInterface::RegisterClassMemberRPC (char *uniqueID, void *functionPointer)=0
virtual void | RakClientInterface::UnregisterAsRemoteProcedureCall (char *uniqueID)=0
virtual bool | RakClientInterface::RPC (char *uniqueID, const char *data, unsigned int bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)=0
virtual bool | RakClientInterface::RPC (char *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)=0
void | RakPeer::RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms))
void | RakPeer::RegisterClassMemberRPC (char *uniqueID, void *functionPointer)
void | RakPeer::UnregisterAsRemoteProcedureCall (char *uniqueID)
bool | RakPeer::RPC (char *uniqueID, const char *data, unsigned int bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)
bool | RakPeer::RPC (char *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)
virtual void | RakPeerInterface::RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms))=0
virtual void | RakPeerInterface::RegisterClassMemberRPC (char *uniqueID, void *functionPointer)=0
virtual void | RakPeerInterface::UnregisterAsRemoteProcedureCall (char *uniqueID)=0
virtual bool | RakPeerInterface::RPC (char *uniqueID, const char *data, unsigned int bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)=0
virtual bool | RakPeerInterface::RPC (char *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)=0
void | RakServer::RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms))
void | RakServer::RegisterClassMemberRPC (char *uniqueID, void *functionPointer)
void | RakServer::UnregisterAsRemoteProcedureCall (char *uniqueID)
bool | RakServer::RPC (char *uniqueID, const char *data, unsigned int bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)
bool | RakServer::RPC (char *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)
virtual void | RakServerInterface::RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionPointer)(RPCParameters *rpcParms))=0
virtual void | RakServerInterface::RegisterClassMemberRPC (char *uniqueID, void *functionPointer)=0
virtual void | RakServerInterface::UnregisterAsRemoteProcedureCall (char *uniqueID)=0
virtual bool | RakServerInterface::RPC (char *uniqueID, const char *data, unsigned int bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)=0
virtual bool | RakServerInterface::RPC (char *uniqueID, RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel, PlayerID playerId, bool broadcast, bool shiftTimestamp, NetworkID networkID, RakNet::BitStream *replyFromTarget)=0

## Detailed Description

A system to call C or object member procudures on other systems, and even to return return values.

## Define Documentation

#define REGISTER_CLASS_MEMBER_RPC | ( | networkObject,
|  | className,
|  | functionName |  | ) | {union {void (__cdecl className::*cFunc)( RPCParameters *rpcParms ); void* voidFunc;}; cFunc=&className::functionName; networkObject->RegisterClassMemberRPC(CLASS_MEMBER_ID(className, functionName),voidFunc);}

  | Register a member function of an instantiated object as a Remote procedure call. RPC member Functions MUST be marked __cdecl! See also: ObjectMemberRPC.cpp CLASS_MEMBER_ID is a utility macro to generate a unique signature for a class and function pair and can be used for the Raknet functions RegisterClassMemberRPC(...) and RPC(...) REGISTER_CLASS_MEMBER_RPC is a utility macro to more easily call RegisterClassMemberRPC Parameters:
  `[in]` | networkObject | Your instance of RakPeer, RakServer, or RakClient
  `[in]` | className | The class containing the function
  `[in]` | functionName | The name of the function (not in quotes, just the name)

#define REGISTER_STATIC_RPC | ( | networkObject,
|  | functionName |  | ) | (networkObject)->RegisterAsRemoteProcedureCall((#functionName),(functionName))

  | RPC Function Implementation. Register a C function as a Remote procedure. Parameters:
  `[in]` | networkObject | Your instance of RakPeer, RakServer, or RakClient
  `[in]` | functionName | The name of the C function to call
Attention: 12/01/05 REGISTER_AS_REMOTE_PROCEDURE_CALL renamed to REGISTER_STATIC_RPC. Delete the old name sometime in the future

#define UNREGISTER_STATIC_RPC | ( | networkObject,
|  | functionName |  | ) | (networkObject)->UnregisterAsRemoteProcedureCall((#functionName))

  | Unregisters a remote procedure call RPC member Functions MUST be marked __cdecl! See the ObjectMemberRPC example. Parameters:
  `[in]` | networkObject | The object that manages the function
  `[in]` | functionName | The function name

## Function Documentation

virtual void RakServerInterface::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(RPCParameters *rpcParms) | functionPointer
| ) | `[pure virtual, inherited]`

  | Register a C or static member function as available for calling as a remote procedure call Parameters:
  `[in]` | uniqueID,: | A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions
  `[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
Implemented in RakServer.

void RakServer::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(RPCParameters *rpcParms) | functionPointer
| ) | `[virtual, inherited]`

  | Register a C or static member function as available for calling as a remote procedure call Parameters:
  `[in]` | uniqueID,: | A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions
  `[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
Reimplemented from RakPeer.

virtual void RakPeerInterface::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(RPCParameters *rpcParms) | functionPointer
| ) | `[pure virtual, inherited]`

  | Register a C or static member function as available for calling as a remote procedure call Parameters:
  `[in]` | uniqueID | A null-terminated unique string to identify this procedure. See RegisterClassMemberRPC() for class member functions.
  `[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
Implemented in RakClient, RakPeer, and RakServer.

void RakPeer::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(RPCParameters *rpcParms) | functionPointer
| ) | `[virtual, inherited]`

  | Register a C or static member function as available for calling as a remote procedure call Parameters:
  `[in]` | uniqueID | A null-terminated unique string to identify this procedure. See RegisterClassMemberRPC() for class member functions.
  `[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
Implements RakPeerInterface. Reimplemented in RakClient, and RakServer.

virtual void RakClientInterface::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(RPCParameters *rpcParms) | functionPointer
| ) | `[pure virtual, inherited]`

  | Register a C or static member function as available for calling as a remote procedure call Parameters:
  `[in]` | uniqueID,: | A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions
  `[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
Implemented in RakClient.

void RakClient::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(RPCParameters *rpcParms) | functionPointer
| ) | `[virtual, inherited]`

  | Register a C or static member function as available for calling as a remote procedure call Parameters:
  `[in]` | uniqueID,: | A null-terminated unique string to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions
  `[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
Implements RakClientInterface.

virtual void RakServerInterface::RegisterClassMemberRPC | ( | char * | uniqueID,
|  | void * | functionPointer
| ) | `[pure virtual, inherited]`

  | Register a C++ member function as available for calling as a remote procedure call. Parameters:
  `[in]` | uniqueID,: | A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC
  `[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
See also: ObjectMemberRPC.cpp Implemented in RakServer.

void RakServer::RegisterClassMemberRPC | ( | char * | uniqueID,
|  | void * | functionPointer
| ) | `[virtual, inherited]`

  | Register a C++ member function as available for calling as a remote procedure call. Parameters:
  `[in]` | uniqueID,: | A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC
  `[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
See also: ObjectMemberRPC.cpp Reimplemented from RakPeer.

virtual void RakPeerInterface::RegisterClassMemberRPC | ( | char * | uniqueID,
|  | void * | functionPointer
| ) | `[pure virtual, inherited]`

  | Register a C++ member function as available for calling as a remote procedure call. Parameters:
  `[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.
  `[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
See also: The sample ObjectMemberRPC.cpp Implemented in RakClient, RakPeer, and RakServer.

void RakPeer::RegisterClassMemberRPC | ( | char * | uniqueID,
|  | void * | functionPointer
| ) | `[virtual, inherited]`

  | Register a C++ member function as available for calling as a remote procedure call. Parameters:
  `[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.
  `[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
See also: The sample ObjectMemberRPC.cpp Implements RakPeerInterface. Reimplemented in RakClient, and RakServer.

virtual void RakClientInterface::RegisterClassMemberRPC | ( | char * | uniqueID,
|  | void * | functionPointer
| ) | `[pure virtual, inherited]`

  | Register a C++ member function as available for calling as a remote procedure call. Parameters:
  `[in]` | uniqueID,: | A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC
  `[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
See also: ObjectMemberRPC.cpp Implemented in RakClient.

void RakClient::RegisterClassMemberRPC | ( | char * | uniqueID,
|  | void * | functionPointer
| ) | `[virtual, inherited]`

  | Register a C++ member function as available for calling as a remote procedure call. Parameters:
  `[in]` | uniqueID,: | A null terminated string to identify this procedure.Recommended you use the macro REGISTER_CLASS_MEMBER_RPC
  `[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
See also: ObjectMemberRPC.cpp Implements RakClientInterface.

virtual bool RakServerInterface::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[pure virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | bitStream | The bitstream to send
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | playerId | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implemented in RakServer.

virtual bool RakServerInterface::RPC | ( | char * | uniqueID,
|  | const char * | data,
|  | unsigned int | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[pure virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | playerId | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Note: This is part of the Remote Procedure Call Subsystem Implemented in RakServer.

bool RakServer::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | bitStream | The bitstream to send
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | playerId | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Reimplemented from RakPeer.

bool RakServer::RPC | ( | char * | uniqueID,
|  | const char * | data,
|  | unsigned int | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | playerId | Who to send this packet to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Reimplemented from RakPeer.

virtual bool RakPeerInterface::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[pure virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terminated string identifying the function to call. Recommended you use the macro CLASS_MEMBER_ID for class member functions.
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on. See PacketPriority.h.
  `[in]` | reliability | How reliability to send this data. See PacketPriority.h.
  `[in]` | orderingChannel | When using ordered or sequenced message, what channel to order these on.
  `[in]` | playerId | Who to send this message to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which should be remotely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implemented in RakPeer, and RakServer.

virtual bool RakPeerInterface::RPC | ( | char * | uniqueID,
|  | const char * | data,
|  | unsigned int | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[pure virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall(). Parameters:
  `[in]` | uniqueID | A NULL terminated string identifying the function to call. Recommended you use the macro CLASS_MEMBER_ID for class member functions.
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on. See PacketPriority.h.
  `[in]` | reliability | How reliability to send this data. See PacketPriority.h.
  `[in]` | orderingChannel | When using ordered or sequenced message, what channel to order these on.
  `[in]` | playerId | Who to send this message to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which should be remotely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implemented in RakPeer, and RakServer.

bool RakPeer::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terminated string identifying the function to call. Recommended you use the macro CLASS_MEMBER_ID for class member functions.
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on. See PacketPriority.h.
  `[in]` | reliability | How reliability to send this data. See PacketPriority.h.
  `[in]` | orderingChannel | When using ordered or sequenced message, what channel to order these on.
  `[in]` | playerId | Who to send this message to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which should be remotely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implements RakPeerInterface. Reimplemented in RakServer.

bool RakPeer::RPC | ( | char * | uniqueID,
|  | const char * | data,
|  | unsigned int | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | PlayerID | playerId,
|  | bool | broadcast,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall(). Parameters:
  `[in]` | uniqueID | A NULL terminated string identifying the function to call. Recommended you use the macro CLASS_MEMBER_ID for class member functions.
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on. See PacketPriority.h.
  `[in]` | reliability | How reliability to send this data. See PacketPriority.h.
  `[in]` | orderingChannel | When using ordered or sequenced message, what channel to order these on.
  `[in]` | playerId | Who to send this message to, or in the case of broadcasting who not to send it to. Use UNASSIGNED_PLAYER_ID to specify none
  `[in]` | broadcast | True to send this packet to all connected systems. If true, then playerId specifies who not to send the packet to.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which should be remotely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implements RakPeerInterface. Reimplemented in RakServer.

virtual bool RakClientInterface::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[pure virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | bitStream | The bitstream to send
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implemented in RakClient.

virtual bool RakClientInterface::RPC | ( | char * | uniqueID,
|  | const char * | data,
|  | unsigned int | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[pure virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Implemented in RakClient.

bool RakClient::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | bitStream | The bitstream to send
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Note: This is part of the Remote Procedure Call Subsystem Implements RakClientInterface.

bool RakClient::RPC | ( | char * | uniqueID,
|  | const char * | data,
|  | unsigned int | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | bool | shiftTimestamp,
|  | NetworkID | networkID,
|  | RakNet::BitStream * | replyFromTarget
| ) | `[virtual, inherited]`

  | Calls a C function on the remote system that was already registered using RegisterAsRemoteProcedureCall. If you want that function to return data you should call RPC from that system in the same wayReturns true on a successful packet send (this does not indicate the recipient performed the call), false on failure Parameters:
  `[in]` | uniqueID | A NULL terimianted string to this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions. Must match the parameter
  `[in]` | data | The data to send
  `[in]` | bitLength | The number of bits of data
  `[in]` | priority | What priority level to send on.
  `[in]` | reliability | How reliability to send this data
  `[in]` | orderingChannel | When using ordered or sequenced packets, what channel to order these on.
  `[in]` | shiftTimestamp | True to add a timestamp to your data, such that the first byte is ID_TIMESTAMP and the next sizeof(RakNetTime) is the timestamp.
  `[in]` | networkID | For static functions, pass UNASSIGNED_NETWORK_ID. For member functions, you must derive from NetworkIDGenerator and pass the value returned by NetworkIDGenerator::GetNetworkID for that object.
  `[in]` | replyFromTarget | If 0, this function is non-blocking. Otherwise it will block while waiting for a reply from the target procedure, which is remtely written to RPCParameters::replyToSender and copied to replyFromTarget. The block will return early on disconnect or if the sent packet is unreliable and more than 3X the ping has elapsed.
Returns: True on a successful packet send (this does not indicate the recipient performed the call), false on failure Note: This is part of the Remote Procedure Call Subsystem Implements RakClientInterface.

virtual void RakServerInterface::UnregisterAsRemoteProcedureCall | ( | char * | uniqueID | ) | `[pure virtual, inherited]`

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline Parameters:
  `[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
Implemented in RakServer.

void RakServer::UnregisterAsRemoteProcedureCall | ( | char * | uniqueID | ) | `[virtual, inherited]`

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline Parameters:
  `[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
Reimplemented from RakPeer.

virtual void RakPeerInterface::UnregisterAsRemoteProcedureCall | ( | char * | uniqueID | ) | `[pure virtual, inherited]`

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registered with RegisterAsRemoteProcedureCall. Only call offline. Parameters:
  `[in]` | uniqueID | A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions.
Implemented in RakClient, RakPeer, and RakServer.

void RakPeer::UnregisterAsRemoteProcedureCall | ( | char * | uniqueID | ) | `[virtual, inherited]`

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registered with RegisterAsRemoteProcedureCall. Only call offline. Parameters:
  `[in]` | uniqueID | A string of only letters to identify this procedure. Recommended you use the macro CLASS_MEMBER_ID for class member functions.
Implements RakPeerInterface. Reimplemented in RakClient, and RakServer.

virtual void RakClientInterface::UnregisterAsRemoteProcedureCall | ( | char * | uniqueID | ) | `[pure virtual, inherited]`

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline Parameters:
  `[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
Implemented in RakClient.

void RakClient::UnregisterAsRemoteProcedureCall | ( | char * | uniqueID | ) | `[virtual, inherited]`

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registeredwith RegisterAsRemoteProcedureCallOnly call offline Parameters:
  `[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
Implements RakClientInterface.