683 lines
31 KiB
C++
683 lines
31 KiB
C++
//====== 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
|