Main Page | Modules | Namespace List | Class Hierarchy | Class List | Directories | File List | Namespace Members | Class Members | File Members | Related Pages

# RakClient Class Reference

Client Peer A client peer is used to contact a server. It can connect to one server a a time. If you need to connect to multiple server at the same time think of using a RakPeer instead of a RakClient. More...

`#include <RakClient.h>`

Inheritance diagram for RakClient:

List of all members.

## Public Member Functions
| RakClient ()
virtual | ~RakClient ()
bool | Connect (char *host, unsigned short serverPort, unsigned short clientPort, unsigned long connectionValidationInteger, int threadSleepTimer)
void | Disconnect (unsigned long blockDuration)
void | InitializeSecurity (char *pubKeyP, char *pubKeyQ)
void | SetPassword (char *_password)
bool | HasPassword (void) const
bool | Send (char *data, const long length, PacketPriority priority, PacketReliability reliability, char orderingChannel)
bool | Send (RakNet::BitStream *bitStream, PacketPriority priority, PacketReliability reliability, char orderingChannel)
Packet * | Receive (void)
void | DeallocatePacket (Packet *packet)
void | PingServer (void)
void | PingServer (char *host, unsigned short serverPort, unsigned short clientPort, bool onlyReplyOnAcceptingConnections)
int | GetAveragePing (void)
int | GetLastPing (void) const
int | GetLowestPing (void) const
int | GetPlayerPing (PlayerID playerId)
void | StartOccasionalPing (void)
void | StopOccasionalPing (void)
bool | IsConnected (void) const
unsigned long | GetSynchronizedRandomInteger (void) const
bool | GenerateCompressionLayer (unsigned long inputFrequencyTable[256], bool inputLayer)
bool | DeleteCompressionLayer (bool inputLayer)
void | RegisterAsRemoteProcedureCall (char *uniqueID, void(*functionName)(char *input, int numberOfBitsOfData, PlayerID sender))
void | UnregisterAsRemoteProcedureCall (char *uniqueID)
bool | RPC (char *uniqueID, char *data, unsigned long bitLength, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp)
bool | RPC (char *uniqueID, RakNet::BitStream *parameters, PacketPriority priority, PacketReliability reliability, char orderingChannel, bool shiftTimestamp)
void | SetTrackFrequencyTable (bool b)
bool | GetSendFrequencyTable (unsigned long outputFrequencyTable[256])
float | GetCompressionRatio (void) const
float | GetDecompressionRatio (void) const
RakNet::BitStream * | GetStaticServerData (void)
void | SetStaticServerData (char *data, const long length)
RakNet::BitStream * | GetStaticClientData (PlayerID playerId)
void | SetStaticClientData (PlayerID playerId, char *data, const long length)
void | SendStaticClientDataToServer (void)
PlayerID | GetServerID (void) const
PlayerID | GetPlayerID (void) const
const char * | PlayerIDToDottedIP (PlayerID playerId) const
void | PushBackPacket (Packet *packet)
bool | SetMTUSize (int size)
int | GetMTUSize (void) const
void | AllowConnectionResponseIPMigration (bool allow)
void | AdvertiseSystem (char *host, unsigned short remotePort)
RakNetStatisticsStruct *const | GetStatistics (void)
PlayerIndex | GetPlayerIndex (void)
## Private Member Functions
int | GetOtherClientIndexByPlayerID (PlayerID playerId)
int | GetFreeOtherClientIndex (void)
## Private Attributes
RakNet::BitStream | password
RakClient::OtherClientsStruct | otherClients [32]
unsigned long | seed
unsigned long | nextSeed
unsigned long | nextSeedUpdate
PlayerIndex | localPlayerIndex
PlayerID | externalPlayerID
## Classes
struct | OtherClientsStruct

## Detailed Description

Client Peer A client peer is used to contact a server. It can connect to one server a a time. If you need to connect to multiple server at the same time think of using a RakPeer instead of a RakClient.

See also:
  RakServer

## Constructor & Destructor Documentation

RakClient::RakClient | ( |  | ) |

| Constructor

RakClient::~RakClient | ( |  | ) | `[virtual]`

| Destructor

## Member Function Documentation

void RakClient::AdvertiseSystem | ( | char * | host,
|  | unsigned short | remotePort
| ) | `[virtual]`

  | Sends a one byte message ID_ADVERTISE_SYSTEM to the remote unconnected system. This will tell the remote system our external IP outside the LAN, and can be used for NAT punch through Parameters:
  | host | Either a dotted IP address or a domain name
  | remotePort | Which port to connect to on the remote machine.
Implements RakClientInterface.

void RakClient::AllowConnectionResponseIPMigration | ( | bool | allow | ) | `[virtual]`

  | Allow or disallow connection responses from any IP. Normally this should be false, but may be necessary when connection to servers with multiple IP addresses. Parameters:
  | allow | True to allow this behavior, false to not allow. Defaults to false. Value persists between connections
Implements RakClientInterface.

bool RakClient::Connect | ( | char * | host,
|  | unsigned short | serverPort,
|  | unsigned short | clientPort,
|  | unsigned long | connectionValidationInteger,
|  | int | threadSleepTimer
| ) | `[virtual]`

  | Call this to connect the client to the specified host (ip or domain name) and server port. This is a non-blocking connection. You know the connection is successful when IsConnected() returns true or receive gets a packet with the type identifier ID_CONNECTION_REQUEST_ACCEPTED. serverPort is which port to connect to on the remote machine. clientPort is the port you want the client to use. Both ports must be open for UDP Parameters:
  | host | a hostname
  | serverPort | The port on which to contact host
  | clientPort | The port to use localy
  | connectionValidationInteger | is legacy and unused
  | threadSleepTimer | >=0 for how many ms to Sleep each internal update cycle (recommended 30 for low performance, 0 for regular)
Returns: true on successful initiation, false otherwise Implements RakClientInterface.

void RakClient::DeallocatePacket | ( | Packet * | packet | ) | `[virtual]`

  | Call this to deallocate a packet returned by Receive when you are done handling it. Free the memory associated to a packet. It is not the same as using delete operator because RakNet might decide not to delete right now the packet in order to use it later. Parameters:
  | packet | the packet to deallocate.
Implements RakClientInterface.

bool RakClient::DeleteCompressionLayer | ( | bool | inputLayer | ) | `[virtual]`

  | Delete the output or input layer as specified. This is not necessary to call and is only valuable for freeing memory You should only call this when disconnected Parameters:
  | inputLayer | Delete the compression layer for sending or for receiving ?
Returns: false (failure) if connected. Otherwise true (success) Implements RakClientInterface.

void RakClient::Disconnect | ( | unsigned long | blockDuration | ) | `[virtual]`

  | Stops the client, stops synchronized data, and resets all internal data. Does nothing if the client is not connected to begin with blockDuration is how long you should wait for all remaining packets to go out If you set it to 0 then the disconnection notification probably won't arrive Parameters:
  | blockDuration | The time to wait before truly close the communication and point
Implements RakClientInterface.

bool RakClient::GenerateCompressionLayer | ( | unsigned long | inputFrequencyTable[256],
|  | bool | inputLayer
| ) | `[virtual]`

  | This is an optional function to generate the compression layer from the input frequency table. You should call this twice - once with inputLayer as true and once as false. The frequency table passed here with inputLayer=true should match the frequency table on the recipient with inputLayer=false. Likewise, the frequency table passed here with inputLayer=false should match the frequency table on the recipient with inputLayer=true Calling this function when there is an existing layer will overwrite the old layer You should only call this when disconnected Parameters:
  | inputFrenquencyTable | the table to used for compression
  | inputLayer | says if the inputFrequencyTable should be used for sending or receiveing.
Returns: false (failure) if connected. Otherwise true (success) Note: The server Sends should share the same inputFrequencyTable as the client for receiving. It's also true for the client sending and the server receiving. Implements RakClientInterface.

int RakClient::GetAveragePing | ( | void |  | ) | `[virtual]`

| Returns the average of all ping times read Returns: the average ping value to the server Implements RakClientInterface.

float RakClient::GetCompressionRatio | ( | void |  | ) | const`[virtual]`

| Returns the compression ratio. A low compression ratio is good. Compression is for outgoing data Returns: the current compression ratio Implements RakClientInterface.

float RakClient::GetDecompressionRatio | ( | void |  | ) | const`[virtual]`

| Returns the decompression ratio. A high decompression ratio is good. Decompression is for incoming data Returns: the current decompression ratio Implements RakClientInterface.

int RakClient::GetFreeOtherClientIndex | ( | void |  | ) | `[private]`

| Get one free client index. Returns: an unsued yet index

int RakClient::GetLastPing | ( | void |  | ) | const`[virtual]`

| Returns the last ping time read for the specific player or -1 if none read yet Returns: last ping value Implements RakClientInterface.

int RakClient::GetLowestPing | ( | void |  | ) | const`[virtual]`

| Returns the lowest ping time read or -1 if none read yet Returns: lowest ping value Implements RakClientInterface.

int RakClient::GetMTUSize | ( | void |  | ) | const`[virtual]`

| Returns the current MTU size Implements RakClientInterface.

int RakClient::GetOtherClientIndexByPlayerID | ( | PlayerID | playerId | ) | `[private]`

  | Get the player index of another client Parameters:
  | playerId | the id of a client
Returns: the index

PlayerID RakClient::GetPlayerID | ( | void |  | ) | const`[virtual]`

| Return the player number the server has assigned to you. Returns: our player ID Note: that unlike in previous versions, this is a struct and is not sequential Implements RakClientInterface.

PlayerIndex RakClient::GetPlayerIndex | ( | void |  | ) | `[virtual]`

| Implements RakClientInterface.

int RakClient::GetPlayerPing | ( | PlayerID | playerId | ) | `[virtual]`

  | Returns the last ping for the specified player. This information is broadcast by the server automatically In order to save bandwidth this information is updated only infrequently and only for the first 32 players Parameters:
  | playerId | The id of the player you want to have the ping (it might be your id)
Returns: the last ping for this player Note: You can read your own ping with this method by passing your own playerId, however for more up-to-date readings you should use one of the three functions above Implements RakClientInterface.

bool RakClient::GetSendFrequencyTable | ( | unsigned long | outputFrequencyTable[256] | ) | `[virtual]`

  | Returns the frequency of outgoing bytes into outputFrequencyTable The purpose is to save to file as either a master frequency table from a sample game session for passing to GenerateCompressionLayer. You should only call this when disconnected. Requires that you first enable data frequency tracking by calling SetTrackFrequencyTable(true) Parameters:
  | outputFrequencyTable | The frequency table produce during the tracking time.
Returns: false (failure) if connected or if frequency table tracking is not enabled. Otherwise true (success) Implements RakClientInterface.

PlayerID RakClient::GetServerID | ( | void |  | ) | const`[virtual]`

| Return the player number of the server. Returns: the server playerID Implements RakClientInterface.

RakNet::BitStream * RakClient::GetStaticClientData | ( | PlayerID | playerId | ) | `[virtual]`

| The client internally maintains a data struct that is automatically sent to the server on connection This is useful to contain data such as the player name. Access that struct with this function. Pass UNASSIGNED_PLAYER_ID for playerId to reference your internal data. A playerId value to access the data of another player. *** NOTE *** If you change any data in the struct the server won't reflect this change unless you manually update it Do so by calling SendStaticClientDataToServer The data is entered as an array and stored and returned as a BitStream. Everytime you call GetStaticServerData it resets the read pointer to the start of the bitstream. To do multiple reads without reseting the pointer Maintain a pointer copy to the bitstream as in RakNet::BitStream *copy = ...->GetStaticServerData(...); To store a bitstream, use the GetData() and GetNumberOfBytesUsed() methods of the bitstream for the 2nd and 3rd parameters Implements RakClientInterface.

RakNet::BitStream * RakClient::GetStaticServerData | ( | void |  | ) | `[virtual]`

| The server internally maintains a data struct that is automatically sent to clients when the connect. This is useful to contain data such as the server name or message of the day. Access that struct with this function. The data is entered as an array and stored and returned as a BitStream. Everytime you call GetStaticServerData it resets the read pointer to the start of the bitstream. To do multiple reads without reseting the pointer Maintain a pointer copy to the bitstream as in RakNet::BitStream *copy = ...->GetStaticServerData(...); To store a bitstream, use the GetData() and GetNumberOfBytesUsed() methods of the bitstream for the 2nd and 3rd parameters Note that the server may change at any time the data contents and/or its length! Returns: a bitstream containing statistics. Implements RakClientInterface.

RakNetStatisticsStruct *const RakClient::GetStatistics | ( | void |  | ) | `[virtual]`

| Returns a structure containing a large set of network statistics for the server/client connection You can map this data to a string using the C style StatisticsToString function Returns: 0 on can't find the specified system. A pointer to a set of data otherwise. Implements RakClientInterface.

unsigned long RakClient::GetSynchronizedRandomInteger | ( | void |  | ) | const`[virtual]`

| Returns a number automatically synchronized between the server and client which randomly changes every 9 seconds. The time it changes is accurate to within a few ms and is best used to seed random number generators that you want to usually return the same output on all systems. Keep in mind this isn't perfectly accurate as there is always a very small chance the numbers will by out of synch during changes so you should confine its use to visual effects or functionality that has a backup method to maintain synchronization. If you don't need this functionality and want to save the bandwidth call StopSynchronizedRandomInteger after starting the server Returns: A random int common to all client and to the server. Implements RakClientInterface.

bool RakClient::HasPassword | ( | void |  | ) | const`[virtual]`

| Returns true if a password was set, false otherwise Returns: true if a password has previously been set using SetPassword Implements RakClientInterface.

void RakClient::InitializeSecurity | ( | char * | pubKeyP,
|  | char * | pubKeyQ
| ) | `[virtual]`

  | Can be called to use specific public RSA keys. (e and n) In order to prevent altered keys. Will return ID_RSA_PUBLIC_KEY_MISMATCH in a packet If a key has been altered. Parameters:
  | pubKeyP | Public keys generated from the RSACrypt class. Can be 0
  | pubKeyQ | Public keys generated from the RSACrypt class. Can be 0
See also: Encryption sample. Implements RakClientInterface.

bool RakClient::IsConnected | ( | void |  | ) | const`[virtual]`

| Returns true if the client is connected to a responsive server Returns: true if connected to a server Implements RakClientInterface.

void RakClient::PingServer | ( | char * | host,
|  | unsigned short | serverPort,
|  | unsigned short | clientPort,
|  | bool | onlyReplyOnAcceptingConnections
| ) | `[virtual]`

  | Sends a ping request to a server we are not connected to. This will also initialize the networking system if it is not already initialized. You can stop the networking system by calling Disconnect() The final ping time will be encoded in the following 4 bytes (2-5) as an unsigned long You can specify if the server should only reply if it has an open connection or not This must be true for LAN broadcast server discovery on "255.255.255.255" or you will get replies from clients as well. Parameters:
  | host | The host to contact
  | ServerPort | the port used by the server
  | clientPort | the port used to receive the answer
  | onlyReplyOnAcceptingConnections | if true the server must be ready to accept incomming connection.
Implements RakClientInterface.

void RakClient::PingServer | ( | void |  | ) | `[virtual]`

| Send a ping request to the server.Occasional pings are on by default (see StartOccasionalPing and StopOccasionalPing) so unless you turn them off it is not necessary to call this function. It is here for completeness if you want it Does nothing if the client is not connected to begin with Implements RakClientInterface.

const char * RakClient::PlayerIDToDottedIP | ( | PlayerID | playerId | ) | const`[virtual]`

  | Returns the dotted IP address for the specified playerId Parameters:
  | playerId | Any player ID other than UNASSIGNED_PLAYER_ID, even if that player is not currently connected
Returns: a dotted notation string representation of the address of playerId. Implements RakClientInterface.

void RakClient::PushBackPacket | ( | Packet * | packet | ) | `[virtual]`

  | Put a packet back at the end of the receive queue in case you don't want to deal with it immediately Parameters:
  | packet | the packet to delayed
Implements RakClientInterface.

Packet * RakClient::Receive | ( | void |  | ) | `[virtual]`

| Call this to get a packet from the incoming packet queue. Use DeallocatePacket to deallocate the packet after you are done with it. Check the Packet struct at the top of CoreNetworkStructures.h for the format of the struct Returns 0 if no packets are waiting to be handled If the client is not active this will also return 0, as all waiting packets are flushed when the client is Disconnected This also updates all memory blocks associated with synchronized memory Returns: the last receive packet Implements RakClientInterface.

void RakClient::RegisterAsRemoteProcedureCall | ( | char * | uniqueID,
|  | void(*)(char *input, int numberOfBitsOfData, PlayerID sender) | functionName
| ) | `[virtual]`

  | Register a C function as available for calling as a remote procedure call uniqueID should be a null terminated non-case senstive string of only letters to identify this procedure Parameter 2 should be the name of the C function or C++ singleton to be used as a function pointer This can be called whether the client is active or not, and registered functions stay registered unless unregistered with UnregisterAsRemoteProcedureCall Parameters:
  | uniqueID | the id of the RPC
  | functionName | a pointer to the C function.
Implements RakClientInterface.

bool RakClient::RPC | ( | char * | uniqueID,
|  | RakNet::BitStream * | parameters,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | bool | shiftTimestamp
| ) | `[virtual]`

| Calls a C function on the server that the server already registered using RegisterAsRemoteProcedureCall Pass the data you want to pass to that function in parameters, or 0 for no data to pass You can also pass a regular data stream which will be converted to a bitstream internally by passing data and bit length If you want that function to return data you should call RPC from that system in the same way Returns true on a successful packet send (this does not indicate the recipient performed the call), false on failure The uniqueID must be composed of a string with only characters from a-z and is not case sensitive Implements RakClientInterface.

bool RakClient::RPC | ( | char * | uniqueID,
|  | char * | data,
|  | unsigned long | bitLength,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel,
|  | bool | shiftTimestamp
| ) | `[virtual]`

| Calls a C function on the server that the server already registered using RegisterAsRemoteProcedureCall Pass the data you want to pass to that function in parameters, or 0 for no data to pass You can also pass a regular data stream which will be converted to a bitstream internally by passing data and bit length If you want that function to return data you should call RPC from that system in the same way Returns true on a successful packet send (this does not indicate the recipient performed the call), false on failure The uniqueID must be composed of a string with only characters from a-z and is not case sensitive Implements RakClientInterface.

bool RakClient::Send | ( | RakNet::BitStream * | bitStream,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel
| ) | `[virtual]`

  | This function only works while the client is connected (Use the Connect function). Returns false on failure, true on success Sends the BitStream If you aren't sure what to specify for priority and reliability, use HIGH_PRIORITY and RELIABLE, 0 for ordering channel Parameters:
  | bitstream | the data to send.
  | priority | the priority of the message
  | reliability | the reliability policy required
  | orderingChannel | the channel to send the message to.
Implements RakClientInterface.

bool RakClient::Send | ( | char * | data,
|  | const long | length,
|  | PacketPriority | priority,
|  | PacketReliability | reliability,
|  | char | orderingChannel
| ) | `[virtual]`

  | This function only works while the client is connected (Use the Connect function). Returns false on failure, true on success Sends the data stream of length length If you aren't sure what to specify for priority and reliability, use HIGH_PRIORITY and RELIABLE, 0 for ordering channel Parameters:
  | data | a byte buffer
  | length | the size of the byte buffer
  | priority | the priority of the message
  | reliability | the reliability policy required
  | orderingChannel | the channel to send the message to.
Implements RakClientInterface.

void RakClient::SendStaticClientDataToServer | ( | void |  | ) | `[virtual]`

| Send the static server data to the server The only time you need to call this function is to update clients that are already connected when you change the static server data by calling GetStaticServerData and directly modifying the object pointed to. Obviously if the connected clients don't need to know the new data you don't need to update them, so it's up to you The server must be active for this to have meaning Implements RakClientInterface.

bool RakClient::SetMTUSize | ( | int | size | ) | `[virtual]`

| Change the MTU size in order to improve performance when sending large packets This can only be called when not connected. Returns false on failure (we are connected). True on success. Maximum allowed size is MAXIMUM_MTU_SIZE A too high of value will cause packets not to arrive at worst and be fragmented at best. A too low of value will split packets unnecessarily. Set according to the following table: 1500. The largest Ethernet packet size; it is also the default value. This is the typical setting for non-PPPoE, non-VPN connections. The default value for NETGEAR routers, adapters and switches. 1492. The size PPPoE prefers. 1472. Maximum size to use for pinging. (Bigger packets are fragmented.) 1468. The size DHCP prefers. 1460. Usable by AOL if you don't have large email attachments, etc. 1430. The size VPN and PPTP prefer. 1400. Maximum size for AOL DSL. 576. Typical value to connect to dial-up ISPs. (Default) Implements RakClientInterface.

void RakClient::SetPassword | ( | char * | _password | ) | `[virtual]`

  | Set the password to use when connecting to a server. The password persists between connections. Pass 0 for no password. Parameters:
  | _password | The password to use to connect to a server
Implements RakClientInterface.

void RakClient::SetStaticClientData | ( | PlayerID | playerId,
|  | char * | data,
|  | const long | length
| ) | `[virtual]`

  | Set Local statistical information for playId. Call this function when you receive statistical information from a client. Parameters:
  | playerId | the player ID
  | data | the packet data
  | length | the size of the data
Implements RakClientInterface.

void RakClient::SetStaticServerData | ( | char * | data,
|  | const long | length
| ) | `[virtual]`

  | The server internally maintains a data struct that is automatically sent to clients when the connect. This is useful to contain data such as the server name or message of the day. Access that struct with this function. The data is entered as an array and stored and returned as a BitStream. Everytime you call GetStaticServerData it resets the read pointer to the start of the bitstream. To do multiple reads without reseting the pointer Maintain a pointer copy to the bitstream as in RakNet::BitStream *copy = ...->GetStaticServerData(...); To store a bitstream, use the GetData() and GetNumberOfBytesUsed() methods of the bitstream for the 2nd and 3rd parameters Note that the server may change at any time the data contents and/or its length! Parameters:
  | data | a byte buffer containing statistical information.
  | length | the size of data
Implements RakClientInterface.

void RakClient::SetTrackFrequencyTable | ( | bool | b | ) | `[virtual]`

  | Enables or disables frequency table tracking. This is required to get a frequency table, which is used to generate A new compression layer. You can call this at any time - however you SHOULD only call it when disconnected. Otherwise you will only track part of the values sent over the network. This value persists between connect calls and defaults to false (no frequency tracking) Parameters:
  | b | true to unable tracking.
Implements RakClientInterface.

void RakClient::StartOccasionalPing | ( | void |  | ) | `[virtual]`

| Ping the server every so often. This is on by default. In games where you don't care about ping you can call StopOccasionalPing to save the bandwidth This will work anytime Implements RakClientInterface.

void RakClient::StopOccasionalPing | ( | void |  | ) | `[virtual]`

| Stop pinging the server every so often. The server is pinged by default. In games where you don't care about ping you can call this to save the bandwidth This will work anytime Implements RakClientInterface.

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

  | Unregisters a C function as available for calling as a remote procedure call that was formerly registered with RegisterAsRemoteProcedureCall Parameters:
  | uniqueID | the id of the RPC.
Implements RakClientInterface.

## Member Data Documentation

PlayerID RakClient::externalPlayerID`[private]`

| This is our external ID (and also IP) (returned from the server)

PlayerIndex RakClient::localPlayerIndex`[private]`

| Our local index

unsigned long RakClient::nextSeed`[private]`

| Synchronized random integer

unsigned long RakClient::nextSeedUpdate`[private]`

| Synchronized random integer

struct RakClient::OtherClientsStruct RakClient::otherClients[ 32 ]`[private]`

| Store other client information

RakNet::BitStream RakClient::password`[private]`

| Store the password for this client

unsigned long RakClient::seed`[private]`

| Synchronized random integer

The documentation for this class was generated from the following files:

- Projects/raknet/include/raknet/RakClient.h
- Projects/raknet/Source/RakClient.cpp