Functions | Friends

Here is a list of all the functions available in the GodotSteam module. The descriptions are pulled from the official Steamworks SDK documentation with modifications made to fit GodotSteam's implementation of the functions. Naturally, any GodotSteam-specific functions will be noted as such.


activateGameOverlay( string dialog )

  • Activates the overlay with optional dialog to open the following: "Friends", "Community", "Players", "Settings", "OfficialGameGroup", "Stats", "Achievements", "LobbyInvite".
  • Returns nothing; void.

activateGameOverlayInviteDialog( int steam_id ) activateGameOverlayInviteDialog( uint64_t steam_id )

  • Activates game overlay to open the invite dialog. Invitations will be sent for the provided lobby.
  • Returns nothing; void.

activateGameOverlayToStore( int app_id ) activateGameOverlayToStore( uint32_t app_id )

  • Activates the overlay with the application/game Steam store page.
  • Returns nothing; void.

activateGameOverlayToUser( string url, int steam_id ) activateGameOverlayToUser( string url, uint32_t steam_id )

  • Activates the overlay to the following: "steamid", "chat", "jointrade", "stats", "achievements", "friendadd", "friendremove", "friendrequestaccept", "friendrequestignore".
  • Returns nothing; void.

activateGameOverlayToWebPage( string url )

  • Activates the overlay with specified web address.
  • Returns nothing; void.

activateGameOverlayInviteDialogConnectString( string connectString )

  • Activates the game overlay to open an invite dialog that will send the provided Rich Presence connect string to selected friends.
  • Note: This function is not in the Steamworks docs but does exist in the SDK itself.
  • Returns nothing; void.

clearRichPresence()

  • Clears all of the current user's Rich Presence key/values.
  • Returns nothing; void.

closeClanChatWindowInSteam( int chat_id ) closeClanChatWindowInSteam( uint64_t chat_id )

  • Closes the specified Steam group chat room in the Steam UI.
  • Returns a bool.

downloadClanActivityCounts( int clan_id, int clans_to_request ) downloadClanActivityCounts( uint64_t clan_id, int clans_to_request )

  • Refresh the Steam Group activity data or get the data from groups other than one that the current user is a member. After receiving the callback you can then use getClanActivityCounts to get the up to date user counts.
  • Triggers a clan_activity_downloaded callback.
  • Return nothing; void.

enumerateFollowingList( int startIndex ) enumerateFollowingList( uint32 startIndex )

  • Gets the list of users that the current user is following. You can be following people that are not your friends. Following allows you to receive updates when the person does things like post a new piece of content to the Steam Workshop.
  • Note: This returns up to k_cEnumerateFollowersMax users at once. If the current user is following more than that, you will need to call this repeatedly, with unStartIndex set to the total number of followers that you have received so far. I.E. If you have received 50 followers, and the user is following 105, you will need to call this again with unStartIndex = 50 to get the next 50, and then again with unStartIndex = 100 to get the remaining 5 users.
  • Triggers a enumerate_following_list callback.
  • Return nothing; void.

getChatMemberByIndex( int clan_id, int user ) getChatMemberByIndex( uint64_t clan_id, int user )

  • Gets the Steam ID at the given index in a Steam group chat.
  • Note: You must call getClanChatMemberCount before calling this.
  • Returns an int. Returns an uint64_t.

getClanActivityCounts( int clan_id ) getClanActivityCounts( uint64_t clan_id )

  • Gets the most recent information we have about what the users in a Steam Group are doing. This can only retrieve data that the local client knows about. To refresh the data or get data from a group other than one that the current user is a member of you must call downloadClanActivityCounts.
  • Returns a dictionary:
    • clan (int)
    • online (int)
    • ingame (int)
    • chatting (int)
    • clan (uint64_t)
    • online (int)
    • ingame (int)
    • chatting (int)

getClanByIndex( int clan )

  • Gets the Steam group's Steam ID at the given index.
  • Notes: You must call getClanCount before calling this.
  • Returns an int. Returns an uint64_t.

getClanChatMemberCount( int clan_id ) getClanChatMemberCount( uint64_t clan_id )

  • Get the number of users in a Steam group chat.
  • Note: Large steam groups cannot be iterated by the local user.
  • Note: The current user must be in a lobby to retrieve the Steam IDs of other users in that lobby. This is used for iteration, after calling this then getChatMemberByIndex can be used to get the Steam ID of each person in the chat.
  • Returns an int.

getClanChatMessage( int chat_id, int message ) getClanChatMessage( int chat_id, int message )

  • Gets the data from a Steam group chat room message. This should only ever be called in response to a connected_clan_chat_message callback.
  • Returns a dictionary:
    • ret (bool)
    • text (string)
    • type (int)
    • chatter (int) as a Steam ID
    • ret (bool)
    • text (string)
    • type (int)
    • chatter (uint64_t) as a Steam ID

getClanCount()

  • Gets the number of Steam groups that the current user is a member of. This is used for iteration, after calling this then getClanByIndex can be used to get the Steam ID of each Steam group.
  • Returns an int.

getClanName( int clan_id ) getClanName( uint64_t clan_id )

  • Gets the display name for the specified Steam group; if the local client knows about it.
  • Returns a string.

getClanOfficerByIndex( int clan_id, int officer ) getClanOfficerByIndex( uint64_t clan_id, int officer )

  • Gets the Steam ID of the officer at the given index in a Steam group.
  • Note: You must call getClanOfficerCount before calling this.
  • Returns an int. Returns an uint64_t.

getClanOfficerCount( int clan_id ) getClanOfficerCount( uint64_t clan_id )

  • Gets the number of officers (administrators and moderators) in a specified Steam group. This also includes the owner of the Steam group. This is used for iteration, after calling this then getClanOfficerByIndex can be used to get the Steam ID of each officer.
  • Note: You must call requestClanOfficerList before this to get the required data.
  • Returns an int.

getClanOwner( int clan_id ) getClanOwner( uint64_t clan_id )

  • Get the steam ID of the clan owner.
  • Returns an int. Returns an uint64_t.

getClanTag( int clan_id ) getClanTag( uint64_t clan_id )

  • Gets the unique tag (abbreviation) for the specified Steam group; If the local client knows about it. The Steam group abbreviation is a unique way for people to identify the group and is limited to 12 characters. In some games this will appear next to the name of group members.
  • Returns a string.

getCoplayFriend( int friend_number )

  • Gets the Steam ID of the recently played with user at the given index.
  • Returns an int. Returns an uint64_t.

getCoplayFriendCount()

  • Gets the number of players that the current users has recently played with, across all games. This is used for iteration, after calling this then getCoplayFriend can be used to get the Steam ID of each player. These players are have been set with previous calls to setPlayedWith.
  • Returns an int.

getFollowerCount( int steam_id ) getFollowerCount( uint64_t steam_id )

  • Gets the number of users following the specified user.
  • Triggers a get_follower_count callback.
  • Returns nothing; void.

getFriendByIndex( int friend_number, int friend_flags )

  • Gets the Steam ID of the user at the given index.
  • Note: You must call getFriendCount before calling this.
  • Returns an int.

getFriendCoplayGame( int friend_id ) getFriendCoplayGame( uint64_t friend_id )

  • Gets the app ID of the game that user played with someone on their recently-played-with list.
  • Returns an int. Returns an uint32_t.

getFriendCoplayTime( int friend_id ) getFriendCoplayTime( uint64_t friend_id )

  • Gets the timestamp of when the user played with someone on their recently-played-with list. The time is provided in Unix epoch format (seconds since Jan 1st 1970).
  • Returns an int.

getFriendCount()

  • Gets the number of users the client knows about who meet a specified criteria. (Friends, blocked, users on the same server, etc). This can be used to iterate over all of the users by calling GetFriendByIndex to get the Steam IDs of each user.
  • Note: Returns -1 if the current user is not logged on.
  • Returns an int.

getFriendCountFromSource( int source_id ) getFriendCountFromSource( uint64_t source_id )

  • Get the number of users in a source (Steam group, chat room, lobby, or game server). This is used for iteration, after calling this then getFriendFromSourceByIndex can be used to get the Steam ID of each person in the source.
  • Note: Large Steam groups cannot be iterated by the local user.
  • Note: If you're getting the number of lobby members then you should use getNumLobbyMembers instead.
  • Returns an int.

getFriendFromSourceByIndex( int source_id, int friend_number ) getFriendFromSourceByIndex( uint64_t source_id, int friend_number )

  • Gets the Steam ID at the given index from a source (Steam group, chat room, lobby, or game server).
  • Note: You must call getFriendCountFromSource before calling this.
  • Returns an int. Returns an uint64_t.

getFriendGamePlayed( int steam_id ) getFriendGamePlayed( uint64_t steam_id )

  • Checks if the specified friend is in a game, and gets info about the game if they are.
  • Returns a dictionary:
    • id (int) as app ID
    • ip (string)
    • game_port (int)
    • query_port (int)
    • lobby (int)
    • id (int) as app ID
    • ip (string)
    • game_port (uint16)
    • query_port (uint16)
    • lobby (uint64_t)

getFriendMessage( int friend_id, int message ) getFriendMessage( uint64_t friend_id, int message )

  • Gets the data from a Steam friends message. This should only ever be called in response to a connected_friend_chat_message callback.
  • Returns a dictionary:
    • ret (int)
    • text (string)

getFriendPersonaName( int steam_id ) getFriendPersonaName( uint64_t steam_id )

  • Gets the specified user's persona (display) name. This will only be known to the current user if the other user is in their friends list, on the same game server, in a chat room or lobby, or in a small Steam group with the local user. To get the persona name of the current user use getPersonaName.
  • Note: Upon on first joining a lobby, chat room, or game server the current user will not known the name of the other users automatically; that information will arrive asynchronously via persona_state_change callbacks.
  • Returns a string.

getFriendPersonaNameHistory( int steam_id, int name_history ) getFriendPersonaNameHistory( uint64_t steam_id, int name_history )

  • Gets one of the previous display names for the specified user. This only works for display names that the current user has seen on the local computer.
  • Returns a string.

getFriendPersonaState( int steam_id ) getFriendPersonaState( uint64_t steam_id )

  • Gets the current status of the specified user. This will only be known to the current user if the other user is in their friends list, on the same game server, in a chat room or lobby, or in a small Steam group with the local user. To get the state of the current user use getPersonaState.
  • Returns an int; should be one of the following:
    • 0 - Offline
    • 1 - Online
    • 2 - Busy
    • 3 - Away
    • 4 - Snooze
    • 5 - Looking For Trade
    • 6 - Looking for Play

getFriendRelationship( int steam_id ) getFriendRelationship( uint64_t steam_id )

  • Gets a relationship to a specified user.
  • Returns an int; should be one of the following:
    • 0 - None
    • 1 - Blocked
    • 2 - Request Recipient
    • 3 - Friend
    • 4 - Request Initiator
    • 5 - Ignored
    • 6 - Ignored Friend
    • 7 - Suggested
    • 8 - Max

getFriendRichPresence( int friend_id, string key ) getFriendRichPresence( uint64_t friend_id, string key )

  • Get a Rich Presence value from a specified friend (typically only used for debugging).
  • Returns a string.

getFriendRichPresenceKeyByIndex( int friend_id, int key ) getFriendRichPresenceKeyByIndex( uint64_t friend_id, int key )

  • Gets an empty string ("") if the index is invalid or the specified user has no Rich Presence data available.
  • Returns a string.

getFriendRichPresenceKeyCount( int friend_id ) getFriendRichPresenceKeyCount( uint64_t friend_id )

  • Gets the number of Rich Presence keys that are set on the specified user. This is used for iteration, after calling this then getFriendRichPresenceKeyByIndex to get the rich presence keys. This is typically only ever used for debugging purposes.
  • Returns an int.

getFriendsGroupCount()

  • Gets the number of friends groups (tags) the user has created. This is used for iteration, after calling this then getFriendsGroupIDByIndex can be used to get the ID of each friend group. This is not to be confused with Steam groups. Those can be obtained with getClanCount.
  • Returns an int.

getFriendsGroupIDByIndex( int friend_group ) getFriendsGroupIDByIndex( int16 friend_group )

  • Gets the friends group ID for the given index.
  • Note: You must call getFriendsGroupCount before calling this.
  • Returns an int. Returns an int16.

getFriendsGroupMemberCount( int friend_group ) getFriendsGroupMemberCount( int16 friend_group )

  • Gets the number of friends in a given friends group. This should be called before getting the list of friends with getFriendsGroupMembersList.
  • Returns an int.

getFriendsGroupMembersList( int friend_group, int member_count ) getFriendsGroupMembersList( int16 friend_group, int member_count )

  • Gets the number of friends in the given friends group. If fewer friends exist than requested those positions' Steam IDs will be invalid. You must call getFriendsGroupMembersCount before calling this to set up the member_count argument with an appropriate size!
  • Returns an array of int friend Steam IDs. Returns an array of uint64_t friend Steam IDs.

getFriendsGroupName( int friend_group ) getFriendsGroupName( uint64_t friend_group )

  • Gets the name for the given friends group.
  • Returns a string.

getFriendSteamLevel( int steam_id ) getFriendSteamLevel( uint64_t steam_id )

  • Gets the Steam level of the specified user. You can use the local users Steam ID to get their level.
  • Returns an int.

getLargeFriendAvatar( int steam_id ) getLargeFriendAvatar( uint64_t steam_id )

  • Gets a handle to the large (128*128px) avatar for the specified user. You can pass in getSteamID to get the current user's avatar.
  • Note: This only works for users that the local user knows about. They will automatically know about their friends, people on leaderboards they've requested, or people in the same source as them (Steam group, chat room, lobby, or game server). If they don't know about them then you must call requestUserInformation to cache the avatar locally.
  • Triggers a avatar_loaded callback.
  • Returns an int which is a Steam image handle which is used with getImageSize and getImageRGBA.

getMediumFriendAvatar( int steam_id ) getMediumFriendAvatar( uint64_t steam_id )

  • Gets a handle to the medium (64*64px) avatar for the specified user. You can pass in getSteamID to get the current user's avatar.
  • Note: This only works for users that the local user knows about. They will automatically know about their friends, people on leaderboards they've requested, or people in the same source as them (Steam group, chat room, lobby, or game server). If they don't know about them then you must call requestUserInformation to cache the avatar locally.
  • Triggers a avatar_loaded callback.
  • Returns an int which is a Steam image handle which is used with getImageSize and getImageRGBA.

getPersonaName()

  • Gets the current user's persona (display) name. This is the same name that is displayed the users community profile page. To get the persona name of other users use getFriendPersonaName.
  • Returns a string.

getPersonaState()

  • Gets the friend status of the current user. To get the state of other users use getFriendPersonaState.
  • Return an int; should be one of the following:
    • 0 - Offline
    • 1 - Online
    • 2 - Busy
    • 3 - Away
    • 4 - Snooze
    • 5 - Looking For Trade
    • 6 - Looking for Play

getPlayerAvatar( int size, int steam_id ) getPlayerAvatar( int size, uint64_t steam_id )

  • Get player's avatar. Short-cuts to the various avatar functions in Steamworks.
  • Note: This is a unique function to GodotSteam.
  • Size is passed as follows:
    • 1 - small avatar
    • 2 - medium avatar
    • 3 - large avatar
  • Triggers a avatar_loaded callback.
  • Returns nothing; void.

getPlayerNickname( int steam_id ) getPlayerNickname( uint64_t steam_id )

  • Gets the nickname that the current user has set for the specified user.
  • Returns a string.

getProfileItemPropertyString( int steam_id, int item_type, int item_property ) getProfileItemPropertyString( uint64_t steam_id, int item_type, int item_property )

  • Returns a string property for a user's equipped profile item.
  • Returns a string.

getProfileItemPropertyInt( int steam_id, int item_type, int item_property ) getProfileItemPropertyInt( uint64_t steam_id, int item_type, int item_property )

  • Returns an unsigned integer property for a user's equipped profile item.
  • Return an intuint32.

getRecentPlayers()

  • Get list of players user has recently played game with.
  • Note: This is a unique function to GodotSteam.
  • Returns an array of:
    • player (dictionary)
      • id (int) as friend Steam ID.
      • name (string)
      • time (int)
      • status (int)
      • id (uint64_t) as friend Steam ID.
      • name (string)
      • time (int)
      • status (int)

getSmallFriendAvatar( int steam_id ) getSmallFriendAvatar( uint64_t steam_id )

  • Gets a handle to the small (32*32px) avatar for the specified user. You can pass in getSteamID to get the current user's avatar.
  • Note: This only works for users that the local user knows about. They will automatically know about their friends, people on leaderboards they've requested, or people in the same source as them (Steam group, chat room, lobby, or game server). If they don't know about them then you must call requestUserInformation to cache the avatar locally.
  • Triggers a avatar_loaded callback.
  • Returns an int which is a Steam image handle which is used with getImageSize and getImageRGBA.

getUserFriendsGroups()

  • Get list of friends groups (tags) the user has created. This is not to be confused with Steam groups.
  • Note: This is a unique function to GodotSteam.
  • Returns an array of:
    • tags (dictionary)
      • id (int) as friend group ID
      • name (string)
      • members (int)
      • id (int16) as friend group ID
      • name (string)
      • members (int)

getUserRestrictions()

  • If current user is chat restricted, they can't send or receive any text or voice chat messages. The user can't see custom avatars. But the user can be online and send or receive game invites. A chat restricted user cannot add friends or join any groups. Restricted users can still be online and send/receive game invites.
  • Returns an int; it should be one of the following: Returns an uint32; it should be one of the following:
    • 0 - None
    • 1 - Unknown
    • 2 - Any Chat
    • 4 - Voice Chat
    • 8 - Group Chat
    • 16 - Rating
    • 32 - Game Invites
    • 64 - Trading

getUserSteamFriends()

  • Get a list of user's Steam friends; a mix of different Steamworks API friend functions.
  • Note: This is a unique function to GodotSteam.
  • Returns an array of:
    • friends (dictionary)
      • id (int) as friend Steam ID
      • name (string)
      • status (int)
      • id (uint64_t) as friend Steam ID
      • name (string)
      • status (int)

getUserSteamGroups()

  • Get list of user's Steam groups; a mix of different Steamworks API group functions.
  • Note: This is a unique function to GodotSteam.
  • Returns an array of:
    • groups (dictionary)
      • id (int) as group ID
      • name (string)
      • tag (string)
      • id (uint64_t) as group ID
      • name (string)
      • tag (string)

hasEquippedProfileItem( int steam_id, int item_type ) hasEquippedProfileItem( uint64_t steam_id, int item_type )

  • After calling RequestEquippedProfileItems, you can use this function to check if the user has a type of profile item equipped or not.
  • Returns a bool.

hasFriend( int steam_id, int friend_flags ) hasFriend( uint64_t steam_id, int friend_flags )

  • Returns true if the specified user meets any of the criteria specified in friendFlags:
    • 0x00 - None
    • 0x01 - Blocked
    • 0x02 - Friendship Requested
    • 0x04 - Immediate
    • 0x08 - Clan Member
    • 0x10 - On Game Server
    • 0x80 - Requesting Friendship
    • 0x100 - Requesting Info
    • 0x200 - Ignored
    • 0x400 - Ignored Friend
    • 0x0000 - Chat Member
    • 0xFFFF - All
  • Returns a bool.

inviteUserToGame( int steam_id, string connectString ) inviteUserToGame( uint64_t steam_id, string connectString )

  • Invites a friend or clan member to the current game using a special invite string. If the target user accepts the invite then the pchConnectString gets added to the command-line when launching the game. If the game is already running for that user, then they will receive a join_game_requested callback with the connect string.
  • Returns a bool.

isClanChatAdmin( int chat_id, int steam_id ) isClanChatAdmin( uint64_t chat_id, uint64_t steam_id )

  • Checks if a user in the Steam group chat room is an admin.
  • Returns a bool.

isClanPublic( int clan_id ) isClanPublic( uint64_t clan_id )

  • Checks if the Steam group is public.
  • Returns a bool.

isClanOfficialGameGroup( int clan_id ) isClanOfficialGameGroup( uint64_t clan_id )

  • Checks if the Steam group is an official game group/community hub.
  • Returns a bool.

isClanChatWindowOpenInSteam( int chat_id ) isClanChatWindowOpenInSteam( uint64_t chat_id )

  • Checks if the Steam Group chat room is open in the Steam UI.
  • Returns a bool.

isFollowing( int steam_id ) isFollowing( uint64_t steam_id )

  • Checks if the current user is following the specified user.
  • Triggers a is_following callback.
  • Returns nothing; void.

isUserInSource( int steam_id, int source_id ) isUserInSource( uint64_t steam_id, uint64_t source_id )

  • Checks if a specified user is in a source (Steam group, chat room, lobby, or game server).
  • Returns a bool.

joinClanChatRoom( int clan_id ) joinClanChatRoom( uint64_t clan_id )

  • Allows the user to join Steam group (clan) chats right within the game. The behavior is somewhat complicated, because the user may or may not be already in the group chat from outside the game or in the overlay. You can use activateGameOverlayToUser to open the in-game overlay version of the chat.
  • Triggers a join_clan_chat_complete callback.
  • May additionally trigger the following callbacks:
    • connect_chat_join
    • connect_chat_leave
    • connect_clan_chat_message
  • Returns nothing; void.

leaveClanChatRoom( int clan_id ) leaveClanChatRoom( uint64_t clan_id )

  • Leaves a Steam group chat that the user has previously entered with joinClanChatRoom.
  • Returns a bool.

openClanChatWindowInSteam( int chat_id ) openClanChatWindowInSteam( uint64_t chat_id )

  • Opens the specified Steam group chat room in the Steam UI.
  • Returns a bool.

registerProtocolInOverlayBrowser( string protocol )

  • Call this before calling activateGameOverlayToWebPage to have the Steam Overlay Browser block navigations to your specified protocol (scheme) uris and instead dispatch a overlay_browser_protocol callback to your game. activateGameOverlayToWebPage must have been called with 1.
  • Note: While this function is in the SDK, it is not listed in the Steamworks docs.
  • Returns a bool.

replyToFriendMessage( int steam_id, string message ) replyToFriendMessage( uint64_t steam_id, string message )

  • Sends a message to a Steam friend.
  • Returns a bool.

requestClanOfficerList( int clan_id ) requestClanOfficerList( uint64_t clan_id )

  • Requests information about a Steam group officers (administrators and moderators).
  • Note: You can only ask about Steam groups that a user is a member of.
  • Note: This won't download avatars for the officers automatically. If no avatar image is available for an officer, then call requestUserInformation to download the avatar.
  • Triggers a request_clan_officer_list callback.
  • Returns nothing; void.

requestFriendRichPresence( int friend_id ) requestFriendRichPresence( uint64_t friend_id )

  • Requests Rich Presence data from a specific user. This is used to get the Rich Presence information from a user that is not a friend of the current user, like someone in the same lobby or game server. This function is rate limited, if you call this too frequently for a particular user then it will just immediately post a callback without requesting new data from the server.
  • Triggers a friend_rich_presence_update callback.
  • Returns nothing; void.

requestUserInformation( int steam_id, bool require_name_only ) requestUserInformation( uint64_t steam_id, bool require_name_only )

  • Requests information about a user, basically the persona name and avatar. If requireNameOnly is set, then the avatar of a user isn't downloaded.
  • Returns a bool.

sendClanChatMessage( int chat_id, string text ) sendClanChatMessage( uint64_t chat_id, string text )

  • Sends a message to a Steam group chat room.
  • Returns a bool.

setInGameVoiceSpeaking( int steam_id, bool speaking ) setInGameVoiceSpeaking( uint64_t steam_id, bool speaking )

  • Let Steam know that the user is currently using voice chat in game. This will suppress the microphone for all voice communication in the Steam UI.
  • Returns nothing; void.

setListenForFriendsMessages( bool intercept )

  • Listens for Steam friends chat messages. You can then show these chats inline in the game. For example with a Blizzard style chat message system or the chat system in Dota 2. After enabling this you will receive connected_friend_chat_message callbacks when ever the user receives a chat message. You can get the actual message data from this callback with getFriendMessage. You can send messages with replyToFriendMessage.
  • Triggers a connected_friend_chat_message callback.
  • Returns a bool.

setPersonaName( string name )

  • Sets the current user's persona name, stores it on the server and publishes the changes to all friends who are online. Changes take place locally immediately, and a persona_state_change callback is posted, presuming success. If the name change fails to happen on the server, then an additional persona_state_change callback will be posted to change the name back, in addition to the final result available in the call result.
  • Triggers a name_changed callback.
  • Returns nothing; void.

setPlayedWith( int steam_id ) setPlayedWith( uint64_t steam_id )

  • Set player as 'Played With' for current game.
  • Note: The current user must be in game with the other player for the association to work.
  • Returns nothing; void.

setRichPresence( string key, string value)

  • Sets a Rich Presence key/value for the current user that is automatically shared to all friends playing the same game. Each user can have up to 20 keys set as defined by k_cchMaxRichPresenceKeys. There are two special keys used for viewing/joining games:
    • "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. This enables the 'join game' button in the 'view game info' dialog, in the steam friends list right click menu, and on the players Steam community profile. Be sure your app implements ISteamApps::GetLaunchCommandLine so you can disable the popup warning when launched via a command line.
  • There are three additional special keys used by the new Steam Chat:
    • "steam_display" - Names a rich presence localization token that will be displayed in the viewing user's selected language in the Steam client UI. See Rich Presence Localization for more info, including a link to a page for testing this rich presence data. If steam_display is not set to a valid localization tag, then rich presence will not be displayed in the Steam client.
    • "steam_player_group" - When set, indicates to the Steam client that the player is a member of a particular group. Players in the same group may be organized together in various places in the Steam UI. This string could identify a party, a server, or whatever grouping is relevant for your game. The string itself is not displayed to users.
    • "steam_player_group_size" - When set, indicates the total number of players in the steam_player_group. The Steam client may use this number to display additional information about a group when all of the members are not part of a user's friends list. (For example, "Bob, Pete, and 4 more".)
  • You can clear all of the keys for the current user with clearRichPresence. To get rich presence keys for friends use getFriendRichPresence.
  • Returns a bool.