//========= Copyright � 1996-2008, Valve LLC, All rights reserved. ============ // // Purpose: // //============================================================================= #ifndef STEAMCLIENTPUBLIC_H #define STEAMCLIENTPUBLIC_H #ifdef _WIN32 #pragma once #endif //lint -save -e1931 -e1927 -e1924 -e613 -e726 // This header file defines the interface between the calling application and the code that // knows how to communicate with the connection manager (CM) from the Steam service // This header file is intended to be portable; ideally this 1 header file plus a lib or dll // is all you need to integrate the client library into some other tree. So please avoid // including or requiring other header files if possible. This header should only describe the // interface layer, no need to include anything about the implementation. #include "steamtypes.h" // General result codes enum EResult { k_EResultOK = 1, // success k_EResultFail = 2, // generic failure k_EResultNoConnection = 3, // no/failed network connection // k_EResultNoConnectionRetry = 4, // OBSOLETE - removed k_EResultInvalidPassword = 5, // password/ticket is invalid k_EResultLoggedInElsewhere = 6, // same user logged in elsewhere k_EResultInvalidProtocolVer = 7, // protocol version is incorrect k_EResultInvalidParam = 8, // a parameter is incorrect k_EResultFileNotFound = 9, // file was not found k_EResultBusy = 10, // called method busy - action not taken k_EResultInvalidState = 11, // called object was in an invalid state k_EResultInvalidName = 12, // name is invalid k_EResultInvalidEmail = 13, // email is invalid k_EResultDuplicateName = 14, // name is not unique k_EResultAccessDenied = 15, // access is denied k_EResultTimeout = 16, // operation timed out k_EResultBanned = 17, // VAC2 banned k_EResultAccountNotFound = 18, // account not found k_EResultInvalidSteamID = 19, // steamID is invalid k_EResultServiceUnavailable = 20, // The requested service is currently unavailable k_EResultNotLoggedOn = 21, // The user is not logged on k_EResultPending = 22, // Request is pending (may be in process, or waiting on third party) k_EResultEncryptionFailure = 23, // Encryption or Decryption failed k_EResultInsufficientPrivilege = 24, // Insufficient privilege k_EResultLimitExceeded = 25, // Too much of a good thing k_EResultRevoked = 26, // Access has been revoked (used for revoked guest passes) k_EResultExpired = 27, // License/Guest pass the user is trying to access is expired k_EResultAlreadyRedeemed = 28, // Guest pass has already been redeemed by account, cannot be acked again k_EResultDuplicateRequest = 29, // The request is a duplicate and the action has already occurred in the past, ignored this time k_EResultAlreadyOwned = 30, // All the games in this guest pass redemption request are already owned by the user k_EResultIPNotFound = 31, // IP address not found k_EResultPersistFailed = 32, // failed to write change to the data store k_EResultLockingFailed = 33, // failed to acquire access lock for this operation k_EResultLogonSessionReplaced = 34, k_EResultConnectFailed = 35, k_EResultHandshakeFailed = 36, k_EResultIOFailure = 37, k_EResultRemoteDisconnect = 38, k_EResultShoppingCartNotFound = 39, // failed to find the shopping cart requested k_EResultBlocked = 40, // a user didn't allow it k_EResultIgnored = 41, // target is ignoring sender k_EResultNoMatch = 42, // nothing matching the request found k_EResultAccountDisabled = 43, k_EResultServiceReadOnly = 44, // this service is not accepting content changes right now k_EResultAccountNotFeatured = 45, // account doesn't have value, so this feature isn't available k_EResultAdministratorOK = 46, // allowed to take this action, but only because requester is admin k_EResultContentVersion = 47, // A Version mismatch in content transmitted within the Steam protocol. k_EResultTryAnotherCM = 48, // The current CM can't service the user making a request, user should try another. k_EResultPasswordRequiredToKickSession = 49,// You are already logged in elsewhere, this cached credential login has failed. k_EResultAlreadyLoggedInElsewhere = 50, // You are already logged in elsewhere, you must wait k_EResultSuspended = 51, // Long running operation (content download) suspended/paused k_EResultCancelled = 52, // Operation canceled (typically by user: content download) k_EResultDataCorruption = 53, // Operation canceled because data is ill formed or unrecoverable k_EResultDiskFull = 54, // Operation canceled - not enough disk space. k_EResultRemoteCallFailed = 55, // an remote call or IPC call failed }; // Error codes for use with the voice functions enum EVoiceResult { k_EVoiceResultOK = 0, k_EVoiceResultNotInitialized = 1, k_EVoiceResultNotRecording = 2, k_EVoiceResultNoData = 3, k_EVoiceResultBufferTooSmall = 4, k_EVoiceResultDataCorrupted = 5, }; // Result codes to GSHandleClientDeny/Kick typedef enum { k_EDenyInvalid = 0, k_EDenyInvalidVersion = 1, k_EDenyGeneric = 2, k_EDenyNotLoggedOn = 3, k_EDenyNoLicense = 4, k_EDenyCheater = 5, k_EDenyLoggedInElseWhere = 6, k_EDenyUnknownText = 7, k_EDenyIncompatibleAnticheat = 8, k_EDenyMemoryCorruption = 9, k_EDenyIncompatibleSoftware = 10, k_EDenySteamConnectionLost = 11, k_EDenySteamConnectionError = 12, k_EDenySteamResponseTimedOut = 13, k_EDenySteamValidationStalled = 14, k_EDenySteamOwnerLeftGuestUser = 15, } EDenyReason; // return type of GetAuthSessionTicket typedef uint32 HAuthTicket; const HAuthTicket k_HAuthTicketInvalid = 0; // results from BeginAuthSession typedef enum { k_EBeginAuthSessionResultOK = 0, // Ticket is valid for this game and this steamID. k_EBeginAuthSessionResultInvalidTicket = 1, // Ticket is not valid. k_EBeginAuthSessionResultDuplicateRequest = 2, // A ticket has already been submitted for this steamID k_EBeginAuthSessionResultInvalidVersion = 3, // Ticket is from an incompatible interface version k_EBeginAuthSessionResultGameMismatch = 4, // Ticket is not for this game k_EBeginAuthSessionResultExpiredTicket = 5, // Ticket has expired } EBeginAuthSessionResult; // Callback values for callback ValidateAuthTicketResponse_t which is a response to BeginAuthSession typedef enum { k_EAuthSessionResponseOK = 0, // Steam has verified the user is online, the ticket is valid and ticket has not been reused. k_EAuthSessionResponseUserNotConnectedToSteam = 1, // The user in question is not connected to steam k_EAuthSessionResponseNoLicenseOrExpired = 2, // The license has expired. k_EAuthSessionResponseVACBanned = 3, // The user is VAC banned for this game. k_EAuthSessionResponseLoggedInElseWhere = 4, // The user account has logged in elsewhere and the session containing the game instance has been disconnected. k_EAuthSessionResponseVACCheckTimedOut = 5, // VAC has been unable to perform anti-cheat checks on this user k_EAuthSessionResponseAuthTicketCanceled = 6, // The ticket has been canceled by the issuer k_EAuthSessionResponseAuthTicketInvalidAlreadyUsed = 7, // This ticket has already been used, it is not valid. k_EAuthSessionResponseAuthTicketInvalid = 8, // This ticket is not from a user instance currently connected to steam. } EAuthSessionResponse; // results from UserHasLicenseForApp typedef enum { k_EUserHasLicenseResultHasLicense = 0, // User has a license for specified app k_EUserHasLicenseResultDoesNotHaveLicense = 1, // User does not have a license for the specified app k_EUserHasLicenseResultNoAuth = 2, // User has not been authenticated } EUserHasLicenseForAppResult; // Steam universes. Each universe is a self-contained Steam instance. enum EUniverse { k_EUniverseInvalid = 0, k_EUniversePublic = 1, k_EUniverseBeta = 2, k_EUniverseInternal = 3, k_EUniverseDev = 4, k_EUniverseRC = 5, k_EUniverseMax }; // Steam account types enum EAccountType { k_EAccountTypeInvalid = 0, k_EAccountTypeIndividual = 1, // single user account k_EAccountTypeMultiseat = 2, // multiseat (e.g. cybercafe) account k_EAccountTypeGameServer = 3, // game server account k_EAccountTypeAnonGameServer = 4, // anonymous game server account k_EAccountTypePending = 5, // pending k_EAccountTypeContentServer = 6, // content server k_EAccountTypeClan = 7, k_EAccountTypeChat = 8, k_EAccountTypeP2PSuperSeeder = 9, // a fake steamid used by superpeers to seed content to users of Steam P2P stuff k_EAccountTypeAnonUser = 10, // Max of 16 items in this field k_EAccountTypeMax }; //----------------------------------------------------------------------------- // types of user game stats fields // WARNING: DO NOT RENUMBER EXISTING VALUES - STORED IN DATABASE //----------------------------------------------------------------------------- enum ESteamUserStatType { k_ESteamUserStatTypeINVALID = 0, k_ESteamUserStatTypeINT = 1, k_ESteamUserStatTypeFLOAT = 2, // Read as FLOAT, set with count / session length k_ESteamUserStatTypeAVGRATE = 3, k_ESteamUserStatTypeACHIEVEMENTS = 4, k_ESteamUserStatTypeGROUPACHIEVEMENTS = 5, }; //----------------------------------------------------------------------------- // Purpose: Chat Entry Types (previously was only friend-to-friend message types) //----------------------------------------------------------------------------- enum EChatEntryType { k_EChatEntryTypeInvalid = 0, k_EChatEntryTypeChatMsg = 1, // Normal text message from another user k_EChatEntryTypeTyping = 2, // Another user is typing (not used in multi-user chat) k_EChatEntryTypeInviteGame = 3, // Invite from other user into that users current game k_EChatEntryTypeEmote = 4, // text emote message k_EChatEntryTypeLobbyGameStart = 5, // lobby game is starting k_EChatEntryTypeLeftConversation = 6, // user has left the conversation ( closed chat window ) // Above are previous FriendMsgType entries, now merged into more generic chat entry types }; //----------------------------------------------------------------------------- // Purpose: Chat Room Enter Responses //----------------------------------------------------------------------------- enum EChatRoomEnterResponse { k_EChatRoomEnterResponseSuccess = 1, // Success k_EChatRoomEnterResponseDoesntExist = 2, // Chat doesn't exist (probably closed) k_EChatRoomEnterResponseNotAllowed = 3, // General Denied - You don't have the permissions needed to join the chat k_EChatRoomEnterResponseFull = 4, // Chat room has reached its maximum size k_EChatRoomEnterResponseError = 5, // Unexpected Error k_EChatRoomEnterResponseBanned = 6, // You are banned from this chat room and may not join }; //----------------------------------------------------------------------------- // Purpose: Status of a given depot version, these are stored in the DB, don't renumber //----------------------------------------------------------------------------- enum EStatusDepotVersion { k_EStatusDepotVersionInvalid = 0, k_EStatusDepotVersionCompleteDisabled = 1, k_EStatusDepotVersionCompleteEnabledBeta = 2, k_EStatusDepotVersionCompleteEnabledPublic = 3, }; typedef void (*PFNLegacyKeyRegistration)( const char *pchCDKey, const char *pchInstallPath ); typedef bool (*PFNLegacyKeyInstalled)(); const int k_unSteamAccountIDMask = 0xFFFFFFFF; const int k_unSteamAccountInstanceMask = 0x000FFFFF; // Special flags for Chat accounts - they go in the top 8 bits // of the steam ID's "instance", leaving 12 for the actual instances enum EChatSteamIDInstanceFlags { k_EChatAccountInstanceMask = 0x00000FFF, // top 8 bits are flags k_EChatInstanceFlagClan = ( k_unSteamAccountInstanceMask + 1 ) >> 1, // top bit k_EChatInstanceFlagLobby = ( k_unSteamAccountInstanceMask + 1 ) >> 2, // next one down, etc // Max of 8 flags }; //----------------------------------------------------------------------------- // Purpose: Possible positions to tell the overlay to show notifications in //----------------------------------------------------------------------------- enum ENotificationPosition { k_EPositionTopLeft = 0, k_EPositionTopRight = 1, k_EPositionBottomLeft = 2, k_EPositionBottomRight = 3, }; #pragma pack( push, 1 ) // Steam ID structure (64 bits total) class CSteamID { public: //----------------------------------------------------------------------------- // Purpose: Constructor //----------------------------------------------------------------------------- CSteamID() { m_steamid.m_comp.m_unAccountID = 0; m_steamid.m_comp.m_EAccountType = k_EAccountTypeInvalid; m_steamid.m_comp.m_EUniverse = k_EUniverseInvalid; m_steamid.m_comp.m_unAccountInstance = 0; } //----------------------------------------------------------------------------- // Purpose: Constructor // Input : unAccountID - 32-bit account ID // eUniverse - Universe this account belongs to // eAccountType - Type of account //----------------------------------------------------------------------------- CSteamID( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType ) { Set( unAccountID, eUniverse, eAccountType ); } //----------------------------------------------------------------------------- // Purpose: Constructor // Input : unAccountID - 32-bit account ID // unAccountInstance - instance // eUniverse - Universe this account belongs to // eAccountType - Type of account //----------------------------------------------------------------------------- CSteamID( uint32 unAccountID, unsigned int unAccountInstance, EUniverse eUniverse, EAccountType eAccountType ) { #if defined(_SERVER) && defined(Assert) Assert( ! ( ( k_EAccountTypeIndividual == eAccountType ) && ( 1 != unAccountInstance ) ) ); // enforce that for individual accounts, instance is always 1 #endif // _SERVER InstancedSet( unAccountID, unAccountInstance, eUniverse, eAccountType ); } //----------------------------------------------------------------------------- // Purpose: Constructor // Input : ulSteamID - 64-bit representation of a Steam ID // Note: Will not accept a uint32 or int32 as input, as that is a probable mistake. // See the stubbed out overloads in the private: section for more info. //----------------------------------------------------------------------------- CSteamID( uint64 ulSteamID ) { SetFromUint64( ulSteamID ); } //----------------------------------------------------------------------------- // Purpose: Sets parameters for steam ID // Input : unAccountID - 32-bit account ID // eUniverse - Universe this account belongs to // eAccountType - Type of account //----------------------------------------------------------------------------- void Set( uint32 unAccountID, EUniverse eUniverse, EAccountType eAccountType ) { m_steamid.m_comp.m_unAccountID = unAccountID; m_steamid.m_comp.m_EUniverse = eUniverse; m_steamid.m_comp.m_EAccountType = eAccountType; if ( eAccountType == k_EAccountTypeClan ) { m_steamid.m_comp.m_unAccountInstance = 0; } else { m_steamid.m_comp.m_unAccountInstance = 1; } } //----------------------------------------------------------------------------- // Purpose: Sets parameters for steam ID // Input : unAccountID - 32-bit account ID // eUniverse - Universe this account belongs to // eAccountType - Type of account //----------------------------------------------------------------------------- void InstancedSet( uint32 unAccountID, uint32 unInstance, EUniverse eUniverse, EAccountType eAccountType ) { m_steamid.m_comp.m_unAccountID = unAccountID; m_steamid.m_comp.m_EUniverse = eUniverse; m_steamid.m_comp.m_EAccountType = eAccountType; m_steamid.m_comp.m_unAccountInstance = unInstance; } //----------------------------------------------------------------------------- // Purpose: Initializes a steam ID from its 52 bit parts and universe/type // Input : ulIdentifier - 52 bits of goodness //----------------------------------------------------------------------------- void FullSet( uint64 ulIdentifier, EUniverse eUniverse, EAccountType eAccountType ) { m_steamid.m_comp.m_unAccountID = ( ulIdentifier & 0xFFFFFFFF ); // account ID is low 32 bits m_steamid.m_comp.m_unAccountInstance = ( ( ulIdentifier >> 32 ) & 0xFFFFF ); // account instance is next 20 bits m_steamid.m_comp.m_EUniverse = eUniverse; m_steamid.m_comp.m_EAccountType = eAccountType; } //----------------------------------------------------------------------------- // Purpose: Initializes a steam ID from its 64-bit representation // Input : ulSteamID - 64-bit representation of a Steam ID //----------------------------------------------------------------------------- void SetFromUint64( uint64 ulSteamID ) { m_steamid.m_unAll64Bits = ulSteamID; } #if defined( INCLUDED_STEAM_COMMON_STEAMCOMMON_H ) //----------------------------------------------------------------------------- // Purpose: Initializes a steam ID from a Steam2 ID structure // Input: pTSteamGlobalUserID - Steam2 ID to convert // eUniverse - universe this ID belongs to //----------------------------------------------------------------------------- void SetFromSteam2( TSteamGlobalUserID *pTSteamGlobalUserID, EUniverse eUniverse ) { m_steamid.m_comp.m_unAccountID = pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits * 2 + pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits; m_steamid.m_comp.m_EUniverse = eUniverse; // set the universe m_steamid.m_comp.m_EAccountType = k_EAccountTypeIndividual; // Steam 2 accounts always map to account type of individual m_steamid.m_comp.m_unAccountInstance = 1; // individual accounts always have an account instance ID of 1 } //----------------------------------------------------------------------------- // Purpose: Fills out a Steam2 ID structure // Input: pTSteamGlobalUserID - Steam2 ID to write to //----------------------------------------------------------------------------- void ConvertToSteam2( TSteamGlobalUserID *pTSteamGlobalUserID ) const { // only individual accounts have any meaning in Steam 2, only they can be mapped // Assert( m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual ); pTSteamGlobalUserID->m_SteamInstanceID = 0; pTSteamGlobalUserID->m_SteamLocalUserID.Split.High32bits = m_steamid.m_comp.m_unAccountID % 2; pTSteamGlobalUserID->m_SteamLocalUserID.Split.Low32bits = m_steamid.m_comp.m_unAccountID / 2; } #endif // defined( INCLUDED_STEAM_COMMON_STEAMCOMMON_H ) //----------------------------------------------------------------------------- // Purpose: Converts steam ID to its 64-bit representation // Output : 64-bit representation of a Steam ID //----------------------------------------------------------------------------- uint64 ConvertToUint64() const { return m_steamid.m_unAll64Bits; } //----------------------------------------------------------------------------- // Purpose: Converts the static parts of a steam ID to a 64-bit representation. // For multiseat accounts, all instances of that account will have the // same static account key, so they can be grouped together by the static // account key. // Output : 64-bit static account key //----------------------------------------------------------------------------- uint64 GetStaticAccountKey() const { // note we do NOT include the account instance (which is a dynamic property) in the static account key return (uint64) ( ( ( (uint64) m_steamid.m_comp.m_EUniverse ) << 56 ) + ((uint64) m_steamid.m_comp.m_EAccountType << 52 ) + m_steamid.m_comp.m_unAccountID ); } //----------------------------------------------------------------------------- // Purpose: create an anonymous game server login to be filled in by the AM //----------------------------------------------------------------------------- void CreateBlankAnonLogon( EUniverse eUniverse ) { m_steamid.m_comp.m_unAccountID = 0; m_steamid.m_comp.m_EAccountType = k_EAccountTypeAnonGameServer; m_steamid.m_comp.m_EUniverse = eUniverse; m_steamid.m_comp.m_unAccountInstance = 0; } //----------------------------------------------------------------------------- // Purpose: create an anonymous game server login to be filled in by the AM //----------------------------------------------------------------------------- void CreateBlankAnonUserLogon( EUniverse eUniverse ) { m_steamid.m_comp.m_unAccountID = 0; m_steamid.m_comp.m_EAccountType = k_EAccountTypeAnonUser; m_steamid.m_comp.m_EUniverse = eUniverse; m_steamid.m_comp.m_unAccountInstance = 0; } //----------------------------------------------------------------------------- // Purpose: Is this an anonymous game server login that will be filled in? //----------------------------------------------------------------------------- bool BBlankAnonAccount() const { return m_steamid.m_comp.m_unAccountID == 0 && BAnonAccount() && m_steamid.m_comp.m_unAccountInstance == 0; } //----------------------------------------------------------------------------- // Purpose: Is this a game server account id? //----------------------------------------------------------------------------- bool BGameServerAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeGameServer || m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer; } //----------------------------------------------------------------------------- // Purpose: Is this a content server account id? //----------------------------------------------------------------------------- bool BContentServerAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeContentServer; } //----------------------------------------------------------------------------- // Purpose: Is this a clan account id? //----------------------------------------------------------------------------- bool BClanAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeClan; } //----------------------------------------------------------------------------- // Purpose: Is this a chat account id? //----------------------------------------------------------------------------- bool BChatAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeChat; } //----------------------------------------------------------------------------- // Purpose: Is this a chat account id? //----------------------------------------------------------------------------- bool IsLobby() const { return ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeChat ) && ( m_steamid.m_comp.m_unAccountInstance & k_EChatInstanceFlagLobby ); } //----------------------------------------------------------------------------- // Purpose: Is this an individual user account id? //----------------------------------------------------------------------------- bool BIndividualAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual; } //----------------------------------------------------------------------------- // Purpose: Is this an anonymous account? //----------------------------------------------------------------------------- bool BAnonAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonUser || m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonGameServer; } //----------------------------------------------------------------------------- // Purpose: Is this an anonymous user account? ( used to create an account or reset a password ) //----------------------------------------------------------------------------- bool BAnonUserAccount() const { return m_steamid.m_comp.m_EAccountType == k_EAccountTypeAnonUser; } // simple accessors void SetAccountID( uint32 unAccountID ) { m_steamid.m_comp.m_unAccountID = unAccountID; } uint32 GetAccountID() const { return m_steamid.m_comp.m_unAccountID; } uint32 GetUnAccountInstance() const { return m_steamid.m_comp.m_unAccountInstance; } EAccountType GetEAccountType() const { return ( EAccountType ) m_steamid.m_comp.m_EAccountType; } EUniverse GetEUniverse() const { return m_steamid.m_comp.m_EUniverse; } void SetEUniverse( EUniverse eUniverse ) { m_steamid.m_comp.m_EUniverse = eUniverse; } bool IsValid() const; // this set of functions is hidden, will be moved out of class explicit CSteamID( const char *pchSteamID, EUniverse eDefaultUniverse = k_EUniverseInvalid ); const char * Render() const; // renders this steam ID to string static const char * Render( uint64 ulSteamID ); // static method to render a uint64 representation of a steam ID to a string void SetFromString( const char *pchSteamID, EUniverse eDefaultUniverse ); bool SetFromSteam2String( const char *pchSteam2ID, EUniverse eUniverse ); inline bool operator==( const CSteamID &val ) const { return m_steamid.m_unAll64Bits == val.m_steamid.m_unAll64Bits; } inline bool operator!=( const CSteamID &val ) const { return !operator==( val ); } inline bool operator<( const CSteamID &val ) const { return m_steamid.m_unAll64Bits < val.m_steamid.m_unAll64Bits; } inline bool operator>( const CSteamID &val ) const { return m_steamid.m_unAll64Bits > val.m_steamid.m_unAll64Bits; } // DEBUG function bool BValidExternalSteamID() const; private: // These are defined here to prevent accidental implicit conversion of a u32AccountID to a CSteamID. // If you get a compiler error about an ambiguous constructor/function then it may be because you're // passing a 32-bit int to a function that takes a CSteamID. You should explicitly create the SteamID // using the correct Universe and account Type/Instance values. CSteamID( uint32 ); CSteamID( int32 ); // 64 bits total union SteamID_t { struct SteamIDComponent_t { uint32 m_unAccountID : 32; // unique account identifier unsigned int m_unAccountInstance : 20; // dynamic instance ID (used for multiseat type accounts only) unsigned int m_EAccountType : 4; // type of account - can't show as EAccountType, due to signed / unsigned difference EUniverse m_EUniverse : 8; // universe this account belongs to } m_comp; uint64 m_unAll64Bits; } m_steamid; }; inline bool CSteamID::IsValid() const { if ( m_steamid.m_comp.m_EAccountType <= k_EAccountTypeInvalid || m_steamid.m_comp.m_EAccountType >= k_EAccountTypeMax ) return false; if ( m_steamid.m_comp.m_EUniverse <= k_EUniverseInvalid || m_steamid.m_comp.m_EUniverse >= k_EUniverseMax ) return false; if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeIndividual ) { if ( m_steamid.m_comp.m_unAccountID == 0 || m_steamid.m_comp.m_unAccountInstance != 1 ) return false; } if ( m_steamid.m_comp.m_EAccountType == k_EAccountTypeClan ) { if ( m_steamid.m_comp.m_unAccountID == 0 || m_steamid.m_comp.m_unAccountInstance != 0 ) return false; } return true; } // generic invalid CSteamID const CSteamID k_steamIDNil; // This steamID comes from a user game connection to an out of date GS that hasnt implemented the protocol // to provide its steamID const CSteamID k_steamIDOutofDateGS( 0, 0, k_EUniverseInvalid, k_EAccountTypeInvalid ); // This steamID comes from a user game connection to an sv_lan GS const CSteamID k_steamIDLanModeGS( 0, 0, k_EUniversePublic, k_EAccountTypeInvalid ); // This steamID can come from a user game connection to a GS that has just booted but hasnt yet even initialized // its steam3 component and started logging on. const CSteamID k_steamIDNotInitYetGS( 1, 0, k_EUniverseInvalid, k_EAccountTypeInvalid ); // This steamID can come from a user game connection to a GS that isn't using the steam authentication system but still // wants to support the "Join Game" option in the friends list const CSteamID k_steamIDNonSteamGS( 2, 0, k_EUniverseInvalid, k_EAccountTypeInvalid ); #ifdef STEAM // Returns the matching chat steamID, with the default instance of 0 // If the steamID passed in is already of type k_EAccountTypeChat it will be returned with the same instance CSteamID ChatIDFromSteamID( const CSteamID &steamID ); // Returns the matching clan steamID, with the default instance of 0 // If the steamID passed in is already of type k_EAccountTypeClan it will be returned with the same instance CSteamID ClanIDFromSteamID( const CSteamID &steamID ); // Asserts steamID type before conversion CSteamID ChatIDFromClanID( const CSteamID &steamIDClan ); // Asserts steamID type before conversion CSteamID ClanIDFromChatID( const CSteamID &steamIDChat ); #endif // _STEAM //----------------------------------------------------------------------------- // Purpose: encapsulates an appID/modID pair //----------------------------------------------------------------------------- class CGameID { public: CGameID() { m_gameID.m_nType = k_EGameIDTypeApp; m_gameID.m_nAppID = k_uAppIdInvalid; m_gameID.m_nModID = 0; } explicit CGameID( uint64 ulGameID ) { m_ulGameID = ulGameID; } explicit CGameID( int32 nAppID ) { m_ulGameID = 0; m_gameID.m_nAppID = nAppID; } explicit CGameID( uint32 nAppID ) { m_ulGameID = 0; m_gameID.m_nAppID = nAppID; } CGameID( uint32 nAppID, uint32 nModID ) { m_ulGameID = 0; m_gameID.m_nAppID = nAppID; m_gameID.m_nModID = nModID; m_gameID.m_nType = k_EGameIDTypeGameMod; } // Hidden functions used only by Steam explicit CGameID( const char *pchGameID ); const char *Render() const; // render this Game ID to string static const char *Render( uint64 ulGameID ); // static method to render a uint64 representation of a Game ID to a string // must include checksum_crc.h first to get this functionality #if defined( CHECKSUM_CRC_H ) CGameID( uint32 nAppID, const char *pchModPath ) { m_ulGameID = 0; m_gameID.m_nAppID = nAppID; m_gameID.m_nType = k_EGameIDTypeGameMod; char rgchModDir[MAX_PATH]; Q_FileBase( pchModPath, rgchModDir, sizeof( rgchModDir ) ); CRC32_t crc32; CRC32_Init( &crc32 ); CRC32_ProcessBuffer( &crc32, rgchModDir, Q_strlen( rgchModDir ) ); CRC32_Final( &crc32 ); // set the high-bit on the mod-id // reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique // replacement for appID's m_gameID.m_nModID = crc32 | (0x80000000); } CGameID( const char *pchExePath, const char *pchAppName ) { m_ulGameID = 0; m_gameID.m_nAppID = k_uAppIdInvalid; m_gameID.m_nType = k_EGameIDTypeShortcut; CRC32_t crc32; CRC32_Init( &crc32 ); CRC32_ProcessBuffer( &crc32, pchExePath, Q_strlen( pchExePath ) ); CRC32_ProcessBuffer( &crc32, pchAppName, Q_strlen( pchAppName ) ); CRC32_Final( &crc32 ); // set the high-bit on the mod-id // reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique // replacement for appID's m_gameID.m_nModID = crc32 | (0x80000000); } #if defined( VSTFILEID_H ) CGameID( VstFileID vstFileID ) { m_ulGameID = 0; m_gameID.m_nAppID = k_uAppIdInvalid; m_gameID.m_nType = k_EGameIDTypeP2P; CRC32_t crc32; CRC32_Init( &crc32 ); const char *pchFileId = vstFileID.Render(); CRC32_ProcessBuffer( &crc32, pchFileId, Q_strlen( pchFileId ) ); CRC32_Final( &crc32 ); // set the high-bit on the mod-id // reduces crc32 to 31bits, but lets us use the modID as a guaranteed unique // replacement for appID's m_gameID.m_nModID = crc32 | (0x80000000); } #endif /* VSTFILEID_H */ #endif /* CHECKSUM_CRC_H */ uint64 ToUint64() const { return m_ulGameID; } uint64 *GetUint64Ptr() { return &m_ulGameID; } bool IsMod() const { return ( m_gameID.m_nType == k_EGameIDTypeGameMod ); } bool IsShortcut() const { return ( m_gameID.m_nType == k_EGameIDTypeShortcut ); } bool IsP2PFile() const { return ( m_gameID.m_nType == k_EGameIDTypeP2P ); } bool IsSteamApp() const { return ( m_gameID.m_nType == k_EGameIDTypeApp ); } uint32 ModID() const { return m_gameID.m_nModID; } uint32 AppID() const { return m_gameID.m_nAppID; } bool operator == ( const CGameID &rhs ) const { return m_ulGameID == rhs.m_ulGameID; } bool operator != ( const CGameID &rhs ) const { return !(*this == rhs); } bool operator < ( const CGameID &rhs ) const { return ( m_ulGameID < rhs.m_ulGameID ); } bool IsValid() const { // each type has it's own invalid fixed point: switch( m_gameID.m_nType ) { case k_EGameIDTypeApp: return m_gameID.m_nAppID != k_uAppIdInvalid; break; case k_EGameIDTypeGameMod: return m_gameID.m_nAppID != k_uAppIdInvalid && m_gameID.m_nModID & 0x80000000; break; case k_EGameIDTypeShortcut: return (m_gameID.m_nModID & 0x80000000) != 0; break; case k_EGameIDTypeP2P: return m_gameID.m_nAppID == k_uAppIdInvalid && m_gameID.m_nModID & 0x80000000; break; default: #if defined(Assert) Assert(false); #endif return false; } } void Reset() { m_ulGameID = 0; } private: enum EGameIDType { k_EGameIDTypeApp = 0, k_EGameIDTypeGameMod = 1, k_EGameIDTypeShortcut = 2, k_EGameIDTypeP2P = 3, }; struct GameID_t { unsigned int m_nAppID : 24; unsigned int m_nType : 8; unsigned int m_nModID : 32; }; union { uint64 m_ulGameID; GameID_t m_gameID; }; }; #pragma pack( pop ) const int k_cchGameExtraInfoMax = 64; //----------------------------------------------------------------------------- // Constants used for query ports. //----------------------------------------------------------------------------- #define QUERY_PORT_NOT_INITIALIZED 0xFFFF // We haven't asked the GS for this query port's actual value yet. #define QUERY_PORT_ERROR 0xFFFE // We were unable to get the query port for this server. #endif // STEAMCLIENTPUBLIC_H