You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
629 lines
28 KiB
629 lines
28 KiB
//====== Copyright (C) 1996-2008, Valve Corporation, All rights reserved. ===== |
|
// |
|
// Purpose: interface to both friends list data and general information about users |
|
// |
|
//============================================================================= |
|
|
|
#ifndef ISTEAMFRIENDS_H |
|
#define ISTEAMFRIENDS_H |
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
#include "isteamclient.h" |
|
#include "steamclientpublic.h" |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: set of relationships to other users |
|
//----------------------------------------------------------------------------- |
|
enum EFriendRelationship |
|
{ |
|
k_EFriendRelationshipNone = 0, |
|
k_EFriendRelationshipBlocked = 1, // this doesn't get stored; the user has just done an Ignore on an friendship invite |
|
k_EFriendRelationshipRequestRecipient = 2, |
|
k_EFriendRelationshipFriend = 3, |
|
k_EFriendRelationshipRequestInitiator = 4, |
|
k_EFriendRelationshipIgnored = 5, // this is stored; the user has explicit blocked this other user from comments/chat/etc |
|
k_EFriendRelationshipIgnoredFriend = 6, |
|
k_EFriendRelationshipSuggested = 7, |
|
|
|
// keep this updated |
|
k_EFriendRelationshipMax = 8, |
|
}; |
|
|
|
// maximum length of friend group name (not including terminating nul!) |
|
const int k_cchMaxFriendsGroupName = 64; |
|
|
|
// maximum number of groups a single user is allowed |
|
const int k_cFriendsGroupLimit = 100; |
|
|
|
// friends group identifier type |
|
typedef int16 FriendsGroupID_t; |
|
|
|
// invalid friends group identifier constant |
|
const FriendsGroupID_t k_FriendsGroupID_Invalid = -1; |
|
|
|
const int k_cEnumerateFollowersMax = 50; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: list of states a friend can be in |
|
//----------------------------------------------------------------------------- |
|
enum EPersonaState |
|
{ |
|
k_EPersonaStateOffline = 0, // friend is not currently logged on |
|
k_EPersonaStateOnline = 1, // friend is logged on |
|
k_EPersonaStateBusy = 2, // user is on, but busy |
|
k_EPersonaStateAway = 3, // auto-away feature |
|
k_EPersonaStateSnooze = 4, // auto-away for a long time |
|
k_EPersonaStateLookingToTrade = 5, // Online, trading |
|
k_EPersonaStateLookingToPlay = 6, // Online, wanting to play |
|
k_EPersonaStateMax, |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: flags for enumerating friends list, or quickly checking a the relationship between users |
|
//----------------------------------------------------------------------------- |
|
enum EFriendFlags |
|
{ |
|
k_EFriendFlagNone = 0x00, |
|
k_EFriendFlagBlocked = 0x01, |
|
k_EFriendFlagFriendshipRequested = 0x02, |
|
k_EFriendFlagImmediate = 0x04, // "regular" friend |
|
k_EFriendFlagClanMember = 0x08, |
|
k_EFriendFlagOnGameServer = 0x10, |
|
// k_EFriendFlagHasPlayedWith = 0x20, // not currently used |
|
// k_EFriendFlagFriendOfFriend = 0x40, // not currently used |
|
k_EFriendFlagRequestingFriendship = 0x80, |
|
k_EFriendFlagRequestingInfo = 0x100, |
|
k_EFriendFlagIgnored = 0x200, |
|
k_EFriendFlagIgnoredFriend = 0x400, |
|
k_EFriendFlagSuggested = 0x800, |
|
k_EFriendFlagAll = 0xFFFF, |
|
}; |
|
|
|
|
|
// friend game played information |
|
#if defined( VALVE_CALLBACK_PACK_SMALL ) |
|
#pragma pack( push, 4 ) |
|
#elif defined( VALVE_CALLBACK_PACK_LARGE ) |
|
#pragma pack( push, 8 ) |
|
#else |
|
#error isteamclient.h must be included |
|
#endif |
|
struct FriendGameInfo_t |
|
{ |
|
CGameID m_gameID; |
|
uint32 m_unGameIP; |
|
uint16 m_usGamePort; |
|
uint16 m_usQueryPort; |
|
CSteamID m_steamIDLobby; |
|
}; |
|
#pragma pack( pop ) |
|
|
|
// maximum number of characters in a user's name. Two flavors; one for UTF-8 and one for UTF-16. |
|
// The UTF-8 version has to be very generous to accomodate characters that get large when encoded |
|
// in UTF-8. |
|
enum |
|
{ |
|
k_cchPersonaNameMax = 128, |
|
k_cwchPersonaNameMax = 32, |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: user restriction flags |
|
//----------------------------------------------------------------------------- |
|
enum EUserRestriction |
|
{ |
|
k_nUserRestrictionNone = 0, // no known chat/content restriction |
|
k_nUserRestrictionUnknown = 1, // we don't know yet (user offline) |
|
k_nUserRestrictionAnyChat = 2, // user is not allowed to (or can't) send/recv any chat |
|
k_nUserRestrictionVoiceChat = 4, // user is not allowed to (or can't) send/recv voice chat |
|
k_nUserRestrictionGroupChat = 8, // user is not allowed to (or can't) send/recv group chat |
|
k_nUserRestrictionRating = 16, // user is too young according to rating in current region |
|
k_nUserRestrictionGameInvites = 32, // user cannot send or recv game invites (e.g. mobile) |
|
k_nUserRestrictionTrading = 64, // user cannot participate in trading (console, mobile) |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: information about user sessions |
|
//----------------------------------------------------------------------------- |
|
struct FriendSessionStateInfo_t |
|
{ |
|
uint32 m_uiOnlineSessionInstances; |
|
uint8 m_uiPublishedToFriendsSessionInstance; |
|
}; |
|
|
|
|
|
|
|
// size limit on chat room or member metadata |
|
const uint32 k_cubChatMetadataMax = 8192; |
|
|
|
// size limits on Rich Presence data |
|
enum { k_cchMaxRichPresenceKeys = 20 }; |
|
enum { k_cchMaxRichPresenceKeyLength = 64 }; |
|
enum { k_cchMaxRichPresenceValueLength = 256 }; |
|
|
|
// These values are passed as parameters to the store |
|
enum EOverlayToStoreFlag |
|
{ |
|
k_EOverlayToStoreFlag_None = 0, |
|
k_EOverlayToStoreFlag_AddToCart = 1, |
|
k_EOverlayToStoreFlag_AddToCartAndShow = 2, |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: interface to accessing information about individual users, |
|
// that can be a friend, in a group, on a game server or in a lobby with the local user |
|
//----------------------------------------------------------------------------- |
|
class ISteamFriends |
|
{ |
|
public: |
|
// returns the local players name - guaranteed to not be NULL. |
|
// this is the same name as on the users community profile page |
|
// this is stored in UTF-8 format |
|
// like all the other interface functions that return a char *, it's important that this pointer is not saved |
|
// off; it will eventually be free'd or re-allocated |
|
virtual const char *GetPersonaName() = 0; |
|
|
|
// Sets the player name, stores it on the server and publishes the changes to all friends who are online. |
|
// Changes take place locally immediately, and a PersonaStateChange_t is posted, presuming success. |
|
// |
|
// The final results are available through the return value SteamAPICall_t, using SetPersonaNameResponse_t. |
|
// |
|
// If the name change fails to happen on the server, then an additional global PersonaStateChange_t will be posted |
|
// to change the name back, in addition to the SetPersonaNameResponse_t callback. |
|
virtual SteamAPICall_t SetPersonaName( const char *pchPersonaName ) = 0; |
|
|
|
// gets the status of the current user |
|
virtual EPersonaState GetPersonaState() = 0; |
|
|
|
// friend iteration |
|
// takes a set of k_EFriendFlags, and returns the number of users the client knows about who meet that criteria |
|
// then GetFriendByIndex() can then be used to return the id's of each of those users |
|
virtual int GetFriendCount( int iFriendFlags ) = 0; |
|
|
|
// returns the steamID of a user |
|
// iFriend is a index of range [0, GetFriendCount()) |
|
// iFriendsFlags must be the same value as used in GetFriendCount() |
|
// the returned CSteamID can then be used by all the functions below to access details about the user |
|
virtual CSteamID GetFriendByIndex( int iFriend, int iFriendFlags ) = 0; |
|
|
|
// returns a relationship to a user |
|
virtual EFriendRelationship GetFriendRelationship( CSteamID steamIDFriend ) = 0; |
|
|
|
// returns the current status of the specified user |
|
// this will only be known by the local user if steamIDFriend is in their friends list; on the same game server; in a chat room or lobby; or in a small group with the local user |
|
virtual EPersonaState GetFriendPersonaState( CSteamID steamIDFriend ) = 0; |
|
|
|
// returns the name another user - guaranteed to not be NULL. |
|
// same rules as GetFriendPersonaState() apply as to whether or not the user knowns the name of the other user |
|
// note that on first joining a lobby, chat room or game server the local user will not known the name of the other users automatically; that information will arrive asyncronously |
|
// |
|
virtual const char *GetFriendPersonaName( CSteamID steamIDFriend ) = 0; |
|
|
|
// returns true if the friend is actually in a game, and fills in pFriendGameInfo with an extra details |
|
virtual bool GetFriendGamePlayed( CSteamID steamIDFriend, OUT_STRUCT() FriendGameInfo_t *pFriendGameInfo ) = 0; |
|
// accesses old friends names - returns an empty string when their are no more items in the history |
|
virtual const char *GetFriendPersonaNameHistory( CSteamID steamIDFriend, int iPersonaName ) = 0; |
|
// friends steam level |
|
virtual int GetFriendSteamLevel( CSteamID steamIDFriend ) = 0; |
|
|
|
// Returns nickname the current user has set for the specified player. Returns NULL if the no nickname has been set for that player. |
|
virtual const char *GetPlayerNickname( CSteamID steamIDPlayer ) = 0; |
|
|
|
// friend grouping (tag) apis |
|
// returns the number of friends groups |
|
virtual int GetFriendsGroupCount() = 0; |
|
// returns the friends group ID for the given index (invalid indices return k_FriendsGroupID_Invalid) |
|
virtual FriendsGroupID_t GetFriendsGroupIDByIndex( int iFG ) = 0; |
|
// returns the name for the given friends group (NULL in the case of invalid friends group IDs) |
|
virtual const char *GetFriendsGroupName( FriendsGroupID_t friendsGroupID ) = 0; |
|
// returns the number of members in a given friends group |
|
virtual int GetFriendsGroupMembersCount( FriendsGroupID_t friendsGroupID ) = 0; |
|
// gets up to nMembersCount members of the given friends group, if fewer exist than requested those positions' SteamIDs will be invalid |
|
virtual void GetFriendsGroupMembersList( FriendsGroupID_t friendsGroupID, OUT_ARRAY_CALL(nMembersCount, GetFriendsGroupMembersCount, friendsGroupID ) CSteamID *pOutSteamIDMembers, int nMembersCount ) = 0; |
|
|
|
// returns true if the specified user meets any of the criteria specified in iFriendFlags |
|
// iFriendFlags can be the union (binary or, |) of one or more k_EFriendFlags values |
|
virtual bool HasFriend( CSteamID steamIDFriend, int iFriendFlags ) = 0; |
|
|
|
// clan (group) iteration and access functions |
|
virtual int GetClanCount() = 0; |
|
virtual CSteamID GetClanByIndex( int iClan ) = 0; |
|
virtual const char *GetClanName( CSteamID steamIDClan ) = 0; |
|
virtual const char *GetClanTag( CSteamID steamIDClan ) = 0; |
|
// returns the most recent information we have about what's happening in a clan |
|
virtual bool GetClanActivityCounts( CSteamID steamIDClan, int *pnOnline, int *pnInGame, int *pnChatting ) = 0; |
|
// for clans a user is a member of, they will have reasonably up-to-date information, but for others you'll have to download the info to have the latest |
|
virtual SteamAPICall_t DownloadClanActivityCounts( ARRAY_COUNT(cClansToRequest) CSteamID *psteamIDClans, int cClansToRequest ) = 0; |
|
|
|
// iterators for getting users in a chat room, lobby, game server or clan |
|
// note that large clans that cannot be iterated by the local user |
|
// note that the current user must be in a lobby to retrieve CSteamIDs of other users in that lobby |
|
// steamIDSource can be the steamID of a group, game server, lobby or chat room |
|
virtual int GetFriendCountFromSource( CSteamID steamIDSource ) = 0; |
|
virtual CSteamID GetFriendFromSourceByIndex( CSteamID steamIDSource, int iFriend ) = 0; |
|
|
|
// returns true if the local user can see that steamIDUser is a member or in steamIDSource |
|
virtual bool IsUserInSource( CSteamID steamIDUser, CSteamID steamIDSource ) = 0; |
|
|
|
// User is in a game pressing the talk button (will suppress the microphone for all voice comms from the Steam friends UI) |
|
virtual void SetInGameVoiceSpeaking( CSteamID steamIDUser, bool bSpeaking ) = 0; |
|
|
|
// activates the game overlay, with an optional dialog to open |
|
// valid options are "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements" |
|
virtual void ActivateGameOverlay( const char *pchDialog ) = 0; |
|
|
|
// activates game overlay to a specific place |
|
// valid options are |
|
// "steamid" - opens the overlay web browser to the specified user or groups profile |
|
// "chat" - opens a chat window to the specified user, or joins the group chat |
|
// "jointrade" - opens a window to a Steam Trading session that was started with the ISteamEconomy/StartTrade Web API |
|
// "stats" - opens the overlay web browser to the specified user's stats |
|
// "achievements" - opens the overlay web browser to the specified user's achievements |
|
// "friendadd" - opens the overlay in minimal mode prompting the user to add the target user as a friend |
|
// "friendremove" - opens the overlay in minimal mode prompting the user to remove the target friend |
|
// "friendrequestaccept" - opens the overlay in minimal mode prompting the user to accept an incoming friend invite |
|
// "friendrequestignore" - opens the overlay in minimal mode prompting the user to ignore an incoming friend invite |
|
virtual void ActivateGameOverlayToUser( const char *pchDialog, CSteamID steamID ) = 0; |
|
|
|
// activates game overlay web browser directly to the specified URL |
|
// full address with protocol type is required, e.g. http://www.steamgames.com/ |
|
virtual void ActivateGameOverlayToWebPage( const char *pchURL ) = 0; |
|
|
|
// activates game overlay to store page for app |
|
virtual void ActivateGameOverlayToStore( AppId_t nAppID, EOverlayToStoreFlag eFlag ) = 0; |
|
|
|
// Mark a target user as 'played with'. This is a client-side only feature that requires that the calling user is |
|
// in game |
|
virtual void SetPlayedWith( CSteamID steamIDUserPlayedWith ) = 0; |
|
|
|
// activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby. |
|
virtual void ActivateGameOverlayInviteDialog( CSteamID steamIDLobby ) = 0; |
|
|
|
// gets the small (32x32) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set |
|
virtual int GetSmallFriendAvatar( CSteamID steamIDFriend ) = 0; |
|
|
|
// gets the medium (64x64) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set |
|
virtual int GetMediumFriendAvatar( CSteamID steamIDFriend ) = 0; |
|
|
|
// gets the large (184x184) avatar of the current user, which is a handle to be used in IClientUtils::GetImageRGBA(), or 0 if none set |
|
// returns -1 if this image has yet to be loaded, in this case wait for a AvatarImageLoaded_t callback and then call this again |
|
virtual int GetLargeFriendAvatar( CSteamID steamIDFriend ) = 0; |
|
|
|
// requests information about a user - persona name & avatar |
|
// if bRequireNameOnly is set, then the avatar of a user isn't downloaded |
|
// - it's a lot slower to download avatars and churns the local cache, so if you don't need avatars, don't request them |
|
// if returns true, it means that data is being requested, and a PersonaStateChanged_t callback will be posted when it's retrieved |
|
// if returns false, it means that we already have all the details about that user, and functions can be called immediately |
|
virtual bool RequestUserInformation( CSteamID steamIDUser, bool bRequireNameOnly ) = 0; |
|
|
|
// requests information about a clan officer list |
|
// when complete, data is returned in ClanOfficerListResponse_t call result |
|
// this makes available the calls below |
|
// you can only ask about clans that a user is a member of |
|
// note that this won't download avatars automatically; if you get an officer, |
|
// and no avatar image is available, call RequestUserInformation( steamID, false ) to download the avatar |
|
virtual SteamAPICall_t RequestClanOfficerList( CSteamID steamIDClan ) = 0; |
|
|
|
// iteration of clan officers - can only be done when a RequestClanOfficerList() call has completed |
|
|
|
// returns the steamID of the clan owner |
|
virtual CSteamID GetClanOwner( CSteamID steamIDClan ) = 0; |
|
// returns the number of officers in a clan (including the owner) |
|
virtual int GetClanOfficerCount( CSteamID steamIDClan ) = 0; |
|
// returns the steamID of a clan officer, by index, of range [0,GetClanOfficerCount) |
|
virtual CSteamID GetClanOfficerByIndex( CSteamID steamIDClan, int iOfficer ) = 0; |
|
// if current user is chat restricted, he can't send or receive any text/voice chat messages. |
|
// the user can't see custom avatars. But the user can be online and send/recv game invites. |
|
// a chat restricted user can't add friends or join any groups. |
|
virtual uint32 GetUserRestrictions() = 0; |
|
|
|
// Rich Presence data is automatically shared between friends who are in the same game |
|
// Each user has a set of Key/Value pairs |
|
// Up to 20 different keys can be set |
|
// There are two magic keys: |
|
// "status" - a UTF-8 string that will show up in the 'view game info' dialog in the Steam friends list |
|
// "connect" - a UTF-8 string that contains the command-line for how a friend can connect to a game |
|
// GetFriendRichPresence() returns an empty string "" if no value is set |
|
// SetRichPresence() to a NULL or an empty string deletes the key |
|
// You can iterate the current set of keys for a friend with GetFriendRichPresenceKeyCount() |
|
// and GetFriendRichPresenceKeyByIndex() (typically only used for debugging) |
|
virtual bool SetRichPresence( const char *pchKey, const char *pchValue ) = 0; |
|
virtual void ClearRichPresence() = 0; |
|
virtual const char *GetFriendRichPresence( CSteamID steamIDFriend, const char *pchKey ) = 0; |
|
virtual int GetFriendRichPresenceKeyCount( CSteamID steamIDFriend ) = 0; |
|
virtual const char *GetFriendRichPresenceKeyByIndex( CSteamID steamIDFriend, int iKey ) = 0; |
|
// Requests rich presence for a specific user. |
|
virtual void RequestFriendRichPresence( CSteamID steamIDFriend ) = 0; |
|
|
|
// rich invite support |
|
// if the target accepts the invite, the pchConnectString gets added to the command-line for launching the game |
|
// if the game is already running, a GameRichPresenceJoinRequested_t callback is posted containing the connect string |
|
// invites can only be sent to friends |
|
virtual bool InviteUserToGame( CSteamID steamIDFriend, const char *pchConnectString ) = 0; |
|
|
|
// recently-played-with friends iteration |
|
// this iterates the entire list of users recently played with, across games |
|
// GetFriendCoplayTime() returns as a unix time |
|
virtual int GetCoplayFriendCount() = 0; |
|
virtual CSteamID GetCoplayFriend( int iCoplayFriend ) = 0; |
|
virtual int GetFriendCoplayTime( CSteamID steamIDFriend ) = 0; |
|
virtual AppId_t GetFriendCoplayGame( CSteamID steamIDFriend ) = 0; |
|
|
|
// chat interface for games |
|
// this allows in-game access to group (clan) chats from in the game |
|
// the behavior is somewhat sophisticated, because the user may or may not be already in the group chat from outside the game or in the overlay |
|
// use ActivateGameOverlayToUser( "chat", steamIDClan ) to open the in-game overlay version of the chat |
|
virtual SteamAPICall_t JoinClanChatRoom( CSteamID steamIDClan ) = 0; |
|
virtual bool LeaveClanChatRoom( CSteamID steamIDClan ) = 0; |
|
virtual int GetClanChatMemberCount( CSteamID steamIDClan ) = 0; |
|
virtual CSteamID GetChatMemberByIndex( CSteamID steamIDClan, int iUser ) = 0; |
|
virtual bool SendClanChatMessage( CSteamID steamIDClanChat, const char *pchText ) = 0; |
|
virtual int GetClanChatMessage( CSteamID steamIDClanChat, int iMessage, void *prgchText, int cchTextMax, EChatEntryType *peChatEntryType, OUT_STRUCT() CSteamID *psteamidChatter ) = 0; |
|
virtual bool IsClanChatAdmin( CSteamID steamIDClanChat, CSteamID steamIDUser ) = 0; |
|
|
|
// interact with the Steam (game overlay / desktop) |
|
virtual bool IsClanChatWindowOpenInSteam( CSteamID steamIDClanChat ) = 0; |
|
virtual bool OpenClanChatWindowInSteam( CSteamID steamIDClanChat ) = 0; |
|
virtual bool CloseClanChatWindowInSteam( CSteamID steamIDClanChat ) = 0; |
|
|
|
// peer-to-peer chat interception |
|
// this is so you can show P2P chats inline in the game |
|
virtual bool SetListenForFriendsMessages( bool bInterceptEnabled ) = 0; |
|
virtual bool ReplyToFriendMessage( CSteamID steamIDFriend, const char *pchMsgToSend ) = 0; |
|
virtual int GetFriendMessage( CSteamID steamIDFriend, int iMessageID, void *pvData, int cubData, EChatEntryType *peChatEntryType ) = 0; |
|
|
|
// following apis |
|
virtual SteamAPICall_t GetFollowerCount( CSteamID steamID ) = 0; |
|
virtual SteamAPICall_t IsFollowing( CSteamID steamID ) = 0; |
|
virtual SteamAPICall_t EnumerateFollowingList( uint32 unStartIndex ) = 0; |
|
}; |
|
|
|
#define STEAMFRIENDS_INTERFACE_VERSION "SteamFriends015" |
|
|
|
// callbacks |
|
#if defined( VALVE_CALLBACK_PACK_SMALL ) |
|
#pragma pack( push, 4 ) |
|
#elif defined( VALVE_CALLBACK_PACK_LARGE ) |
|
#pragma pack( push, 8 ) |
|
#else |
|
#error isteamclient.h must be included |
|
#endif |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called when a friends' status changes |
|
//----------------------------------------------------------------------------- |
|
struct PersonaStateChange_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 4 }; |
|
|
|
uint64 m_ulSteamID; // steamID of the friend who changed |
|
int m_nChangeFlags; // what's changed |
|
}; |
|
|
|
|
|
// used in PersonaStateChange_t::m_nChangeFlags to describe what's changed about a user |
|
// these flags describe what the client has learned has changed recently, so on startup you'll see a name, avatar & relationship change for every friend |
|
enum EPersonaChange |
|
{ |
|
k_EPersonaChangeName = 0x0001, |
|
k_EPersonaChangeStatus = 0x0002, |
|
k_EPersonaChangeComeOnline = 0x0004, |
|
k_EPersonaChangeGoneOffline = 0x0008, |
|
k_EPersonaChangeGamePlayed = 0x0010, |
|
k_EPersonaChangeGameServer = 0x0020, |
|
k_EPersonaChangeAvatar = 0x0040, |
|
k_EPersonaChangeJoinedSource= 0x0080, |
|
k_EPersonaChangeLeftSource = 0x0100, |
|
k_EPersonaChangeRelationshipChanged = 0x0200, |
|
k_EPersonaChangeNameFirstSet = 0x0400, |
|
k_EPersonaChangeFacebookInfo = 0x0800, |
|
k_EPersonaChangeNickname = 0x1000, |
|
k_EPersonaChangeSteamLevel = 0x2000, |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: posted when game overlay activates or deactivates |
|
// the game can use this to be pause or resume single player games |
|
//----------------------------------------------------------------------------- |
|
struct GameOverlayActivated_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 31 }; |
|
uint8 m_bActive; // true if it's just been activated, false otherwise |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called when the user tries to join a different game server from their friends list |
|
// game client should attempt to connect to specified server when this is received |
|
//----------------------------------------------------------------------------- |
|
struct GameServerChangeRequested_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 32 }; |
|
char m_rgchServer[64]; // server address ("127.0.0.1:27015", "tf2.valvesoftware.com") |
|
char m_rgchPassword[64]; // server password, if any |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called when the user tries to join a lobby from their friends list |
|
// game client should attempt to connect to specified lobby when this is received |
|
//----------------------------------------------------------------------------- |
|
struct GameLobbyJoinRequested_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 33 }; |
|
CSteamID m_steamIDLobby; |
|
|
|
// The friend they did the join via (will be invalid if not directly via a friend) |
|
// |
|
// On PS3, the friend will be invalid if this was triggered by a PSN invite via the XMB, but |
|
// the account type will be console user so you can tell at least that this was from a PSN friend |
|
// rather than a Steam friend. |
|
CSteamID m_steamIDFriend; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called when an avatar is loaded in from a previous GetLargeFriendAvatar() call |
|
// if the image wasn't already available |
|
//----------------------------------------------------------------------------- |
|
struct AvatarImageLoaded_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 34 }; |
|
CSteamID m_steamID; // steamid the avatar has been loaded for |
|
int m_iImage; // the image index of the now loaded image |
|
int m_iWide; // width of the loaded image |
|
int m_iTall; // height of the loaded image |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: marks the return of a request officer list call |
|
//----------------------------------------------------------------------------- |
|
struct ClanOfficerListResponse_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 35 }; |
|
CSteamID m_steamIDClan; |
|
int m_cOfficers; |
|
uint8 m_bSuccess; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: callback indicating updated data about friends rich presence information |
|
//----------------------------------------------------------------------------- |
|
struct FriendRichPresenceUpdate_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 36 }; |
|
CSteamID m_steamIDFriend; // friend who's rich presence has changed |
|
AppId_t m_nAppID; // the appID of the game (should always be the current game) |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: called when the user tries to join a game from their friends list |
|
// rich presence will have been set with the "connect" key which is set here |
|
//----------------------------------------------------------------------------- |
|
struct GameRichPresenceJoinRequested_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 37 }; |
|
CSteamID m_steamIDFriend; // the friend they did the join via (will be invalid if not directly via a friend) |
|
char m_rgchConnect[k_cchMaxRichPresenceValueLength]; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: a chat message has been received for a clan chat the game has joined |
|
//----------------------------------------------------------------------------- |
|
struct GameConnectedClanChatMsg_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 38 }; |
|
CSteamID m_steamIDClanChat; |
|
CSteamID m_steamIDUser; |
|
int m_iMessageID; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: a user has joined a clan chat |
|
//----------------------------------------------------------------------------- |
|
struct GameConnectedChatJoin_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 39 }; |
|
CSteamID m_steamIDClanChat; |
|
CSteamID m_steamIDUser; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: a user has left the chat we're in |
|
//----------------------------------------------------------------------------- |
|
struct GameConnectedChatLeave_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 40 }; |
|
CSteamID m_steamIDClanChat; |
|
CSteamID m_steamIDUser; |
|
bool m_bKicked; // true if admin kicked |
|
bool m_bDropped; // true if Steam connection dropped |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: a DownloadClanActivityCounts() call has finished |
|
//----------------------------------------------------------------------------- |
|
struct DownloadClanActivityCountsResult_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 41 }; |
|
bool m_bSuccess; |
|
}; |
|
|
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: a JoinClanChatRoom() call has finished |
|
//----------------------------------------------------------------------------- |
|
struct JoinClanChatRoomCompletionResult_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 42 }; |
|
CSteamID m_steamIDClanChat; |
|
EChatRoomEnterResponse m_eChatRoomEnterResponse; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: a chat message has been received from a user |
|
//----------------------------------------------------------------------------- |
|
struct GameConnectedFriendChatMsg_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 43 }; |
|
CSteamID m_steamIDUser; |
|
int m_iMessageID; |
|
}; |
|
|
|
|
|
struct FriendsGetFollowerCount_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 44 }; |
|
EResult m_eResult; |
|
CSteamID m_steamID; |
|
int m_nCount; |
|
}; |
|
|
|
|
|
struct FriendsIsFollowing_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 45 }; |
|
EResult m_eResult; |
|
CSteamID m_steamID; |
|
bool m_bIsFollowing; |
|
}; |
|
|
|
|
|
struct FriendsEnumerateFollowingList_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 46 }; |
|
EResult m_eResult; |
|
CSteamID m_rgSteamID[ k_cEnumerateFollowersMax ]; |
|
int32 m_nResultsReturned; |
|
int32 m_nTotalResultCount; |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: reports the result of an attempt to change the user's persona name |
|
//----------------------------------------------------------------------------- |
|
struct SetPersonaNameResponse_t |
|
{ |
|
enum { k_iCallback = k_iSteamFriendsCallbacks + 47 }; |
|
|
|
bool m_bSuccess; // true if name change succeeded completely. |
|
bool m_bLocalSuccess; // true if name change was retained locally. (We might not have been able to communicate with Steam) |
|
EResult m_result; // detailed result code |
|
}; |
|
|
|
|
|
#pragma pack( pop ) |
|
|
|
#endif // ISTEAMFRIENDS_H
|
|
|