259 lines
16 KiB
C++
259 lines
16 KiB
C++
|
|
#ifndef ISTEAMFRIENDS016_H
|
|
#define ISTEAMFRIENDS016_H
|
|
#ifdef STEAM_WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// 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 ISteamFriends016
|
|
{
|
|
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.
|
|
STEAM_CALL_RESULT( SetPersonaNameResponse_t )
|
|
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, STEAM_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.
|
|
// DEPRECATED: GetPersonaName follows the Steam nickname preferences, so apps shouldn't need to care about nicknames explicitly.
|
|
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, STEAM_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( STEAM_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 include "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements",
|
|
// "chatroomgroup/nnnn"
|
|
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
|
|
STEAM_CALL_RESULT( ClanOfficerListResponse_t )
|
|
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
|
|
// Note the following limits: k_cchMaxRichPresenceKeys, k_cchMaxRichPresenceKeyLength, k_cchMaxRichPresenceValueLength
|
|
// 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, a GameRichPresenceJoinRequested_t callback is posted containing the connect string.
|
|
// (Or you can configure yout game so that it is passed on the command line instead. This is a deprecated path; ask us if you really need this.)
|
|
// 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
|
|
STEAM_CALL_RESULT( JoinClanChatRoomCompletionResult_t )
|
|
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, STEAM_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
|
|
STEAM_CALL_RESULT( FriendsGetFollowerCount_t )
|
|
virtual SteamAPICall_t GetFollowerCount( CSteamID steamID ) = 0;
|
|
STEAM_CALL_RESULT( FriendsIsFollowing_t )
|
|
virtual SteamAPICall_t IsFollowing( CSteamID steamID ) = 0;
|
|
STEAM_CALL_RESULT( FriendsEnumerateFollowingList_t )
|
|
virtual SteamAPICall_t EnumerateFollowingList( uint32 unStartIndex ) = 0;
|
|
|
|
virtual bool IsClanPublic( CSteamID steamIDClan ) = 0;
|
|
virtual bool IsClanOfficialGameGroup( CSteamID steamIDClan ) = 0;
|
|
|
|
/// Return the number of chats (friends or chat rooms) with unread messages.
|
|
/// A "priority" message is one that would generate some sort of toast or
|
|
/// notification, and depends on user settings.
|
|
///
|
|
/// You can register for UnreadChatMessagesChanged_t callbacks to know when this
|
|
/// has potentially changed.
|
|
virtual int GetNumChatsWithUnreadPriorityMessages() = 0;
|
|
};
|
|
|
|
|
|
|
|
#endif // ISTEAMFRIENDS016_H
|