Main Page | Namespace List | Class Hierarchy | Alphabetical List | Class List | Directories | File List | Namespace Members | Class Members | File Members

SecurePlayLibrary::SPGameAPIClass Class Reference

#include <SPGameAPIClass.h>

Inheritance diagram for SecurePlayLibrary::SPGameAPIClass:

SecurePlayLibrary::SPGameAPIInterface List of all members.

Detailed Description

The Game API Class is the interface used to communicate with the Game Object as well as to manage the creation of the various types of transactions and other activities associated with controlling a Game.
Author:
IT GlobalSecure
See also:
SecurePlay License Information


Public Member Functions

 SPGameAPIClass (SPGameClass *game)
 SPGameAPIClass ()
 ~SPGameAPIClass ()
bool APIbeginGame (string playerID)
bool APIendGame (string playerID)
string GetNextGameSegmentID (string currentsegment)
bool isPlayerInternal (string pid)
bool isPlayerIncluded (string pid)
SPAbstractTransactionInterface * buildTransaction (string transtype, SPGameClass *gameobj, string master, vector< string > playerIDList, bool privateflag, string transactionID)
bool APIcloseTransaction (string transID)
SPAbstractTransactionInterface * APIcreateTransaction (string transtype, string transmaster, vector< string > playerIDList, bool privateflag)
bool APIBcreateTransaction (string transtype, string transmaster, vector< string > playerIDList, bool privateflag)
SPAbstractTransactionAPIInterface * APITAOcreateTransaction (string transtype, string transmaster, vector< string > playerIDList, bool privateflag)
bool onnewTransaction (SPMessageClass *incoming)
bool APIPlayerJoin (string sender, string pid, string cid)
bool APIPlayerJoin (string sender, string pid, string cid, bool rflag)
bool onPlayerJoin (SPMessageClass *messObj)
bool joinPlayer (string pid, string cid, bool rflag)
bool rulesnewplayerconfig (string pid, string cid, bool rflag)
bool APIrequestbeginGame (string playerID)
bool APIrequestendGame (string playerID)
bool APIrequestcreateTransaction (string pid, string transmaster, string transtype, vector< string > playerIDList, bool privateflagIN)
bool APIrequestPlayerJoin (string sender, string pid, string cid, bool rflagIN)
bool onrequestcreateTransaction (SPMessageClass *incoming)
bool onrequestPlayerJoin (SPMessageClass *messObj)
bool rulesbeginGame (string requesterID)
bool rulesendGame (string requesterID)
bool rulesPlayerJoin (string sender, vector< string > messbody)
bool rulescreateTransaction (string sender, string transtype, string master, vector< string > players, bool pflag)
string APIgetLicenseSummary ()
SPLogInterface * APIgetGameLog ()
void * APIgetGameLogCurrentEntry ()
int APIgetGameLogLength ()
void * APIgetGameLogNextEntry ()
void * APIgetGameLogPreviousEntry ()
vector< string > APIgetOpenTransactionIDs ()
SPAbstractTransactionAPIInterface * APIgetTransactionAPI (string tid)
void logError ()
bool sendMessage (string sender, vector< string > receivers, bool encryptflag, bool privateflag, string messagetype, vector< string > messagebody, vector< string > altmessage)
SPAbstractTransactionInterface * APIgetTransaction (string tid)
bool APIAddListener (SPEventInterface *gameobj)
bool APIRemoveListener (SPEventInterface *gameobj)
vector< SPEventInterface * > APIGetListeners ()
bool APIClearListeners ()
int APIGetListenerCount ()
SPTBlastClass * APIcreateBlastTransaction (string pid, vector< string > transcontent)
void onBlast (SPMessageClass *messObj)
SPPlayerInterface * APIgetPlayer (string pid)
SPGameClass * getGameinstance ()
bool isLibrarytestmode ()
vector< string > APIgetPlayerIDList ()
bool APInewGameBlock (string pid, vector< string > receivers, string gameblocktype, string gameblockID, vector< string > gameblockparameters)
void onnewGameBlock (SPMessageClass *messObj)

Public Attributes

const string extendedversion
const string releaseversion

Private Member Functions

 SPGameAPIClass (const SPGameAPIClass &p)
 operator= (const SPGameAPIClass &p)
SPTBlastClass * buildBlastTransaction (string pid, vector< string > transcontent)

Private Attributes

SPGameClass * gameinstance
const bool librarytestmode

Constructor & Destructor Documentation

SecurePlayLibrary::SPGameAPIClass::SPGameAPIClass (  const SPGameAPIClass &  p  )  [inline, private]
 

Private Copy Constructor that protects this class from being copied.

SPGameAPIClass::SPGameAPIClass (  SPGameClass *  game  ) 
 

Overloaded Constructor

Parameters:
gameinstance SPAbstractGameClass - this parameter is set to this.gameinstance

SPGameAPIClass::SPGameAPIClass (   ) 
 

Default Constructor.

SPGameAPIClass::~SPGameAPIClass (   ) 
 

Default Destructor.

Member Function Documentation

bool SPGameAPIClass::APIAddListener (  SPEventInterface *  gameobj  )  [virtual]
 

This method adds a listener object for Game API events

Parameters:
gameobj SPEventInterface* - the object to be added, that inplement the listener interface
Returns:
bool - TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIBcreateTransaction (  string  transtype,
string  transmaster,
vector< string >  playerIDList,
bool  privateflag
)  [virtual]
 

This method allows the creation of a new, internally controlled transaction. It also sends a message to the other transaction and game participants about this new transaction. NOTE: Thims method may not be supported

Parameters:
transtype string - specified transaction type
transmaster string - player id of the master of the transaction
playerIDList vector<string> - This is an array that holds the Player IDs of the players within the game that are participating in this transaction.
privateflag bool - This is a flag to describe whether the specific transaction is a private transaction to the non-participating Players.
Returns:
bool: TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIbeginGame (  string  playerID  )  [virtual]
 

This method safely begins the game

Parameters:
playerID string - player id is the master.
Returns:
bool: TRUE- if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIClearListeners (   )  [virtual]
 

This method clears the listener objects for Game API events

Returns:
bool - TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIcloseTransaction (  string  transID  )  [virtual]
 

This method removes a transaction from the game instance's open transaction list.

Parameters:
transID string - transaction id to beremoved.
Returns:
bool: TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPTBlastClass * SPGameAPIClass::APIcreateBlastTransaction (  string  pid,
vector< string >  transcontent
)  [virtual]
 

This method creates a default Blast Transaction for this library.

Parameters:
pid string - player id.
transcontent vector<string> - content of this transaction.
Returns:
SPTBlastClass* - pointer to the created transaction.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPAbstractTransactionInterface * SPGameAPIClass::APIcreateTransaction (  string  transtype,
string  transmaster,
vector< string >  playerIDList,
bool  privateflag
)  [virtual]
 

This method allows the creation of a new, internally controlled transaction. It also sends a message to the other transaction and game participants about this new transaction. NOTE: Thims method may not be supported

Parameters:
transtype string - specified transaction type
transmaster string - player id of the master of the transaction
playerIDList vector<string> - This is an array that holds the Player IDs of the players within the game that are participating in this transaction.
privateflag bool - This is a flag to describe whether the specific transaction is a private transaction to the non-participating Players.
Returns:
SPAbstractTransactionInterface* - if successful, null if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIendGame (  string  playerID  )  [virtual]
 

This method safely ends a game.

Parameters:
playerID string - player id is the master.
Returns:
bool: TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPLogInterface * SPGameAPIClass::APIgetGameLog (   )  [virtual]
 

Gets the messagelog object from the gameinstance

Returns:
SPLogInterface* - this object contains the message logs of the game instance.

Implements SecurePlayLibrary::SPGameAPIInterface.

void * SPGameAPIClass::APIgetGameLogCurrentEntry (   )  [virtual]
 

Returns current entry from the messagelog object of comms

Returns:
void* - this is the current entry in the message log

Implements SecurePlayLibrary::SPGameAPIInterface.

int SPGameAPIClass::APIgetGameLogLength (   )  [virtual]
 

returns the number entries in messagelog

Returns:
int - this is the length or number of messages in the game message log object.

Implements SecurePlayLibrary::SPGameAPIInterface.

void * SPGameAPIClass::APIgetGameLogNextEntry (   )  [virtual]
 

Returns the next entry from the messagelog object of comms

Returns:
void* - this is the next entry in the message log

Implements SecurePlayLibrary::SPGameAPIInterface.

void * SPGameAPIClass::APIgetGameLogPreviousEntry (   )  [virtual]
 

Returns the previous entry from the messagelog object of the comms

Returns:
void* - this is the previous entry in the message log

Implements SecurePlayLibrary::SPGameAPIInterface.

string SPGameAPIClass::APIgetLicenseSummary (   )  [virtual]
 

This method returns a summary of the licensee information for the current game instance. This information needs to be publicly available from any game instance, see SecurePlay license for details.

Returns:
string - this string contains full license information.

Implements SecurePlayLibrary::SPGameAPIInterface.

int SPGameAPIClass::APIGetListenerCount (   )  [virtual]
 

This method returns the number of listener objects for Game API events

Returns:
int - the number of listeners

Implements SecurePlayLibrary::SPGameAPIInterface.

vector< SPEventInterface * > SPGameAPIClass::APIGetListeners (   )  [virtual]
 

This method returns a list of listener objects for Game API events

Returns:
vector<SPEventInterface*> - array of listener objects

Implements SecurePlayLibrary::SPGameAPIInterface.

vector< string > SPGameAPIClass::APIgetOpenTransactionIDs (   )  [virtual]
 

Returns a vector that contains a list of open transaction IDs

Returns:
vector<string> - the list of open transaction ids.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPPlayerInterface * SPGameAPIClass::APIgetPlayer (  string  pid  )  [virtual]
 

This method gets the player from the game instance using the player ID

Parameters:
pid string - the player ID
Returns:
SPPlayerInterface* - the player from the game instance.

Implements SecurePlayLibrary::SPGameAPIInterface.

vector< string > SPGameAPIClass::APIgetPlayerIDList (   )  [virtual]
 

This method gets the player id list list associated with this game.

Returns:
vector<string> - player id list.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPAbstractTransactionInterface * SPGameAPIClass::APIgetTransaction (  string  tid  )  [virtual]
 

This method gets the transaction from the game instance using the transaction ID

Parameters:
tid string - the transaction id
Returns:
SPAbstractTransactionInterface* - the transaction from the game instance.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPAbstractTransactionAPIInterface * SPGameAPIClass::APIgetTransactionAPI (  string  tid  )  [virtual]
 

This method returns the transaction API of the game transaction using sid.

Parameters:
tid string - the transaction id.
Returns:
SPAbstractTransactionAPIInterface* - the transaction API.

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APInewGameBlock (  string  pid,
vector< string >  receivers,
string  gameblocktype,
string  gameblockID,
vector< string >  gameblockparameters
) 
 

This method notifies other players of a new GameBlock. GameBlocks are sets of rules or modules of code that can be associated with transactions.

Parameters:
pid string - player id of the master
receivers vector<string> - array of receivers
gameblocktype string - type of GameBlock
gameblockID string - unique ID of GameBlock
gameblockparameters vector<string> - GameBlock parameters
Returns:
bool - whether the message was sent or not.

bool SPGameAPIClass::APIPlayerJoin (  string  sender,
string  pid,
string  cid,
bool  rflag
)  [virtual]
 

This method carries out the local process of adding a new Player to the local game instance.

Parameters:
pid string - player id to be joined
cid string - comms id to used
rflag bool - relay flag
Returns:
bool: TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIPlayerJoin (  string  sender,
string  pid,
string  cid
)  [virtual]
 

This method allows the Game instance Master to safely add a new player during the course of a game and to notify the remote players of this information.

Parameters:
sender string - player id of the sender
pid string - player id to be joined
cid string - comms id to be used
Returns:
bool: TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIRemoveListener (  SPEventInterface *  gameobj  )  [virtual]
 

This method removes a listener object for Game API events

Parameters:
gameobj SPEventInterface* - the object to be removed, that inplement the listener interface
Returns:
bool - TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIrequestbeginGame (  string  playerID  )  [virtual]
 

This method sends a request to the game instance master to begin the game.

Parameters:
playerID string - id of player who is requesting
Returns:
bool: TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIrequestcreateTransaction (  string  pid,
string  transmaster,
string  transtype,
vector< string >  playerIDList,
bool  privateflagIN
)  [virtual]
 

This method safely allows a player to request the creation of a new transaction of a given type and parameters.

Parameters:
pid string - player id of the player who is requesting (cannot be the master)
transmaster string - player id of the master.
transtype string - transaction type to be created
playerIDList vector<string> - This is an array that holds the Player IDs of the players within the game that are participating in this transaction.
privateflagIN bool - This is a flag to describe whether the specific transaction is a private transaction to the non-participating Players.
Returns:
bool: TRUE, if request sent successfully, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIrequestendGame (  string  playerID  )  [virtual]
 

This method sends a message from the specified player to the game instance master to end the game.

Parameters:
playerID string - id of the player requesting
Returns:
bool: TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::APIrequestPlayerJoin (  string  sender,
string  pid,
string  cid,
bool  rflagIN
)  [virtual]
 

This method sends a request to a remote game instance to add a player during a game. Note, only the game master can add a player.

Parameters:
sender string - player id of the player who is requesting (can not be the master).
pid string - player id of the master.
cid string - comms id.
rflagIN bool - relay flag
Returns:
bool: TRUE, if request successfully sent, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

SPAbstractTransactionAPIInterface * SPGameAPIClass::APITAOcreateTransaction (  string  transtype,
string  transmaster,
vector< string >  playerIDList,
bool  privateflag
)  [virtual]
 

This method allows the creation of a new, internally controlled transaction. It also sends a message to the other transaction and game participants about this new transaction. NOTE: Thims method may not be supported

Parameters:
transtype string - specified transaction type
transmaster string - player id of the master of the transaction
playerIDList vector<string> - This is an array that holds the Player IDs of the players within the game that are participating in this transaction.
privateflag bool - This is a flag to describe whether the specific transaction is a private transaction to the non-participating Players.
Returns:
SPAbstractTransactionAPIInterface* - if successful, null if not

Implements SecurePlayLibrary::SPGameAPIInterface.

SPTBlastClass * SPGameAPIClass::buildBlastTransaction (  string  pid,
vector< string >  transcontent
)  [private]
 

This method actually constructs the Blast Transaction

Parameters:
pid string - master of the transaction
transcontent vector<string> - transaction content
Returns:
SPTBlastClass* - the transaction that was created

SPAbstractTransactionInterface * SPGameAPIClass::buildTransaction (  string  transtype,
SPGameClass *  gameobj,
string  master,
vector< string >  playerIDList,
bool  privateflag,
string  transactionID
) 
 

This method builds a local transaction associated with a game instance.

Parameters:
transtype string - specified transaction type.
gameobj SPGameClass* - the game to associated with.
master string - the master of the game
playerIDList vector<string> - This is an array that holds the Player IDs of the players within the game that are participating in this transaction.
privateflag bool - This is a flag to describe whether the specific transaction is a private transaction to the non-participating Players.
transactionID string - This variable holds the unique identifier for the transaction instance within a game instance.
Returns:
SPAbstractTransactionInterface* - if successful, null if not

SPGameClass * SPGameAPIClass::getGameinstance (   )  [virtual]
 

Getter function that returns the property: gameinstance

Returns:
SPGameClass*

Implements SecurePlayLibrary::SPGameAPIInterface.

string SPGameAPIClass::GetNextGameSegmentID (  string  currentsegment  )  [virtual]
 

This method gets automatically called by the Game any time the conditions for a new Game Segment are met according to the SecurePlay Library license. THIS FUNCTION IS A STUB - A global system for unique game segment generation needs to be created in compliance with the SecurePlay license. NOTE - An initial Game Segment needs to be set for each individual game played online this is highly variable - it could be set by a server, a client, a peer, or other system on a case-by-case basis. The base Game Segment ID is provided by SecurePlay.com. One party to the game or supporting the game is responsible for setting the Game Segment ID - the master for the game transaction in this reference implementation. REMOVAL, CIRCUMVENTION, OR DELETION OF THIS FUNCTION IS A VIOLATION OF THE SECUREPLAY LICENSE. ANY CHANGES MUST BE COORDINATED - SEE THE SECUREPLAY LICENSE FOR DETAILS.

Parameters:
currentsegment string - current game segment, but currently not used because the method is a shell.
Returns:
string - new game segement ID

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::isLibrarytestmode (   ) 
 

Getter function that returns the property: librarytestmode

Returns:
librarytestmode - bool

bool SPGameAPIClass::isPlayerIncluded (  string  pid  )  [virtual]
 

This method tests to determine if a specified player is a transaction participant.

Parameters:
pid string - player id to be checked.
Returns:
bool: TRUE, if internal, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::isPlayerInternal (  string  pid  )  [virtual]
 

This method checks to see whether a specified playerID is internal to the local SecurePlay library process

Parameters:
pid string - player id to be checked.
Returns:
bool: TRUE, if internal, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::joinPlayer (  string  pid,
string  cid,
bool  rflag
)  [virtual]
 

This method carries out the local process of adding a new Player to the local game instance.

Parameters:
pid string - player id to be joined
cid string - comms id to used
rflag bool - relay flag
Returns:
bool: TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

void SPGameAPIClass::logError (   ) 
 

Shell Function.

void SPGameAPIClass::onBlast (  SPMessageClass *  messObj  )  [virtual]
 

This method handles incoming new Blast Transactions

Parameters:
messObj SPMessageClass* - incoming Message Object

Implements SecurePlayLibrary::SPGameAPIInterface.

void SPGameAPIClass::onnewGameBlock (  SPMessageClass *  messObj  )  [virtual]
 

This method handles incoming new Game Blocks

Parameters:
messObj SPMessageClass* - incoming Message Object

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::onnewTransaction (  SPMessageClass *  incoming  )  [virtual]
 

This method handles messages for new incoming transactions. It ensures that the new transactions are safely instantiated and loaed into the game.

Parameters:
incoming SPMessageClass - the incoming message.
Returns:
bool: TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::onPlayerJoin (  SPMessageClass *  messObj  )  [virtual]
 

This method safely handles remote messages for the addition of a player to the local game instance.

Parameters:
messObj SPMessageClass* - incoming Message Object
Returns:
bool: TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::onrequestcreateTransaction (  SPMessageClass *  incoming  )  [virtual]
 

This method handles incoming requests for the creation of new transactions. Only the proposed transaction master can create a new transaction.

Parameters:
incoming SPMessageClass* - incoming message
Returns:
bool - TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::onrequestPlayerJoin (  SPMessageClass *  messObj  )  [virtual]
 

Safely handles requests to add a player. Only the Game Master can add a player.

Parameters:
messObj SPMessageClass* - incoming Message Object
Returns:
bool - TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

SecurePlayLibrary::SPGameAPIClass::operator= (  const SPGameAPIClass &  p  )  [inline, private]
 

Private = operator that protects this class from being copied.

bool SPGameAPIClass::rulesbeginGame (  string  requesterID  )  [virtual]
 

This is a shell function to allow the insertion of rules code for the decision to begin a game.

Parameters:
requesterID string - the id of the player who requested the request.
Returns:
bool - TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::rulescreateTransaction (  string  sender,
string  transtype,
string  master,
vector< string >  players,
bool  pflag
)  [virtual]
 

This method safely allows a player to request the creation of a new transaction of a given type and parameters.

Parameters:
sender string - the id of the player who requested the request.
transtype string - the transaction type to be created
master string - the id of the master of the transaction.
players vector<string> - This is an array that holds the Player IDs of the players within the game that are participating in this transaction.
pflag bool - This is a flag to describe whether the specific transaction is a private transaction to the non-participating Players.
Returns:
bool: TRUE, if request sent successfully, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::rulesendGame (  string  requesterID  )  [virtual]
 

This is a shell method to allow the evaluation of the game rules to determine if the game should be allowed to end.

Parameters:
requesterID string - the id of the player who requested the request.
Returns:
bool, TRUE, if successful, FALSE, if not.

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::rulesnewplayerconfig (  string  pid,
string  cid,
bool  rflag
)  [virtual]
 

This shell method takes an incoming proposed configuration for a new player and maps it against the local preference for that player, if different.

Parameters:
pid string - player id of the player to be configured
cid string - comms id
rflag bool - relay flag
Returns:
bool - whether this is accepted or not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::rulesPlayerJoin (  string  sender,
vector< string >  messbody
)  [virtual]
 

This is a shell method to determine if a player will be allowed to join in midgame. Only the Game Master can implement this request.

Parameters:
sender string - the id of the player who requested the request.
messbody vector<string> - the message
Returns:
bool - TRUE, if allowed, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

bool SPGameAPIClass::sendMessage (  string  sender,
vector< string >  receivers,
bool  encryptflag,
bool  privateflag,
string  messagetype,
vector< string >  messagebody,
vector< string >  altmessage
)  [virtual]
 

This method is a wrapper for the game instance sendMessage() method.

Parameters:
sender string - id of the sender
receivers vector<string> - ids of the recievers of the message
encryptflag bool - encryption flag
privateflag bool - private flag
messagetype string - the type of message
messagebody vector<string> - the message body
altmessage vector<string> - alternative message
Returns:
bool - TRUE, if successful, FALSE, if not

Implements SecurePlayLibrary::SPGameAPIInterface.

Member Data Documentation

const string SecurePlayLibrary::SPGameAPIClass::extendedversion
 

Developer extended version.

SPGameClass* SecurePlayLibrary::SPGameAPIClass::gameinstance [private]
 

This is the handler for the associated game instance object

const bool SecurePlayLibrary::SPGameAPIClass::librarytestmode [private]
 

This should be set to FALSE for production systems or all "rulesXXXX methods should be edited

const string SecurePlayLibrary::SPGameAPIClass::releaseversion
 

IT GlobalSecure release version.

The documentation for this class was generated from the following files: 2006 Copyright Filed by IT GlobalSecure, Inc. All Rights Reserved. Not to be used without authorization by Author. SecurePlay, IT GlobalSecure, and IT Armor are registered trademarks by IT GlobalSecure, Inc. Software protected by software license, and one or more the following U.S. and International patent numbers: U.S. Patent 6,030,288, U.S. Patent 6,165,072, European Patent Office EP1016049A1,and World Intellectual Property Organization WO9912135C1 and additional filings worldwide.