diff options
Diffstat (limited to 'lsteamclient/steamworks_sdk_122/isteamfriends.h')
| -rw-r--r-- | lsteamclient/steamworks_sdk_122/isteamfriends.h | 590 |
1 files changed, 590 insertions, 0 deletions
diff --git a/lsteamclient/steamworks_sdk_122/isteamfriends.h b/lsteamclient/steamworks_sdk_122/isteamfriends.h new file mode 100644 index 00000000..379b8162 --- /dev/null +++ b/lsteamclient/steamworks_sdk_122/isteamfriends.h @@ -0,0 +1,590 @@ +//====== 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,
+ k_EFriendRelationshipRequestRecipient = 2,
+ k_EFriendRelationshipFriend = 3,
+ k_EFriendRelationshipRequestInitiator = 4,
+ k_EFriendRelationshipIgnored = 5,
+ 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;
+
+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
+#pragma pack( push, 8 )
+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, 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;
+
+ // 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( 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
+ 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 *, CSteamID * ) = 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 "SteamFriends013"
+
+// callbacks
+#pragma pack( push, 8 )
+
+//-----------------------------------------------------------------------------
+// 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,
+};
+
+
+//-----------------------------------------------------------------------------
+// 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
|