#################
ISteamMatchmaking
#################

.. note::
   This documentation is auto-generated. Methods marked with 🤖 are automatically generated bindings.
   Methods marked with ✍️ are manually implemented and methods marked with ✋ are currently not implemented.

List of Functions
-----------------

* :func:`Matchmaking.AddFavoriteGame`
* :func:`Matchmaking.AddRequestLobbyListCompatibleMembersFilter`
* :func:`Matchmaking.AddRequestLobbyListDistanceFilter`
* :func:`Matchmaking.AddRequestLobbyListFilterSlotsAvailable`
* :func:`Matchmaking.AddRequestLobbyListNearValueFilter`
* :func:`Matchmaking.AddRequestLobbyListNumericalFilter`
* :func:`Matchmaking.AddRequestLobbyListResultCountFilter`
* :func:`Matchmaking.AddRequestLobbyListStringFilter`
* :func:`Matchmaking.CreateLobby`
* :func:`Matchmaking.DeleteLobbyData`
* :func:`Matchmaking.GetFavoriteGame`
* :func:`Matchmaking.GetFavoriteGameCount`
* :func:`Matchmaking.GetLobbyByIndex`
* :func:`Matchmaking.GetLobbyChatEntry`
* :func:`Matchmaking.GetLobbyData`
* :func:`Matchmaking.GetLobbyDataByIndex`
* :func:`Matchmaking.GetLobbyDataCount`
* :func:`Matchmaking.GetLobbyGameServer`
* :func:`Matchmaking.GetLobbyMemberByIndex`
* :func:`Matchmaking.GetLobbyMemberData`
* :func:`Matchmaking.GetLobbyMemberLimit`
* :func:`Matchmaking.GetLobbyOwner`
* :func:`Matchmaking.GetNumLobbyMembers`
* :func:`Matchmaking.InviteUserToLobby`
* :func:`Matchmaking.JoinLobby`
* :func:`Matchmaking.LeaveLobby`
* :func:`Matchmaking.RemoveFavoriteGame`
* :func:`Matchmaking.RequestLobbyData`
* :func:`Matchmaking.RequestLobbyList`
* :func:`Matchmaking.SendLobbyChatMsg`
* :func:`Matchmaking.SetLinkedLobby`
* :func:`Matchmaking.SetLobbyData`
* :func:`Matchmaking.SetLobbyGameServer`
* :func:`Matchmaking.SetLobbyJoinable`
* :func:`Matchmaking.SetLobbyMemberData`
* :func:`Matchmaking.SetLobbyMemberLimit`
* :func:`Matchmaking.SetLobbyOwner`
* :func:`Matchmaking.SetLobbyType`

List of Callbacks
-----------------

* :func:`Matchmaking.OnFavoritesListChanged`
* :func:`Matchmaking.OnLobbyInvite`
* :func:`Matchmaking.OnLobbyEnter`
* :func:`Matchmaking.OnLobbyDataUpdate`
* :func:`Matchmaking.OnLobbyChatUpdate`
* :func:`Matchmaking.OnLobbyChatMsg`
* :func:`Matchmaking.OnLobbyGameCreated`
* :func:`Matchmaking.OnLobbyMatchList`
* :func:`Matchmaking.OnLobbyKicked`
* :func:`Matchmaking.OnLobbyCreated`
* :func:`Matchmaking.OnFavoritesListAccountsUpdated`

Function Reference
------------------

.. function:: Matchmaking.AddFavoriteGame(nAppID, nIP, nConnPort, nQueryPort, unFlags, rTime32LastPlayedOnServer)

    🤖 **Auto-generated binding**

    :param int - AppId_t nAppID:
    :param int nIP:
    :param int nConnPort:
    :param int nQueryPort:
    :param int unFlags:
    :param int rTime32LastPlayedOnServer:
    :returns: (int) Return value
    :SteamWorks: `AddFavoriteGame <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddFavoriteGame>`_

.. function:: Matchmaking.AddRequestLobbyListCompatibleMembersFilter(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :SteamWorks: `AddRequestLobbyListCompatibleMembersFilter <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListCompatibleMembersFilter>`_

.. function:: Matchmaking.AddRequestLobbyListDistanceFilter(eLobbyDistanceFilter)

    🤖 **Auto-generated binding**

    :param int - ELobbyDistanceFilter eLobbyDistanceFilter:
    :SteamWorks: `AddRequestLobbyListDistanceFilter <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListDistanceFilter>`_

.. function:: Matchmaking.AddRequestLobbyListFilterSlotsAvailable(nSlotsAvailable)

    🤖 **Auto-generated binding**

    :param int nSlotsAvailable:
    :SteamWorks: `AddRequestLobbyListFilterSlotsAvailable <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListFilterSlotsAvailable>`_

.. function:: Matchmaking.AddRequestLobbyListNearValueFilter(pchKeyToMatch, nValueToBeCloseTo)

    🤖 **Auto-generated binding**

    :param str? pchKeyToMatch:
    :param int nValueToBeCloseTo:
    :SteamWorks: `AddRequestLobbyListNearValueFilter <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListNearValueFilter>`_

.. function:: Matchmaking.AddRequestLobbyListNumericalFilter(pchKeyToMatch, nValueToMatch, eComparisonType)

    🤖 **Auto-generated binding**

    :param str? pchKeyToMatch:
    :param int nValueToMatch:
    :param int - ELobbyComparison eComparisonType:
    :SteamWorks: `AddRequestLobbyListNumericalFilter <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListNumericalFilter>`_

.. function:: Matchmaking.AddRequestLobbyListResultCountFilter(cMaxResults)

    🤖 **Auto-generated binding**

    :param int cMaxResults:
    :SteamWorks: `AddRequestLobbyListResultCountFilter <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListResultCountFilter>`_

    **Notes:**

    * See :func:`MatchMaking.RequestLobbyList`'s example.

.. function:: Matchmaking.AddRequestLobbyListStringFilter(pchKeyToMatch, pchValueToMatch, eComparisonType)

    🤖 **Auto-generated binding**

    :param str? pchKeyToMatch:
    :param str? pchValueToMatch:
    :param int - ELobbyComparison eComparisonType:
    :SteamWorks: `AddRequestLobbyListStringFilter <https://partner.steamgames.com/doc/api/ISteamMatchmaking#AddRequestLobbyListStringFilter>`_

    **Notes:**

    * See :func:`MatchMaking.RequestLobbyList`'s example.

.. function:: Matchmaking.CreateLobby(eLobbyType, cMaxMembers, callback)

    🤖 **Auto-generated binding**

    :param int - ELobbyType eLobbyType:
    :param int cMaxMembers:
    :param function callback: CallResult callback receiving struct :func:`LobbyCreated_t <Matchmaking.OnLobbyCreated>` and a boolean
    :returns: (uint64) ``SteamAPICall_t`` handle for this async call. The result is delivered via the ``callback`` parameter when :func:`Steam.RunCallbacks` is called.
    :SteamWorks: `CreateLobby <https://partner.steamgames.com/doc/api/ISteamMatchmaking#CreateLobby>`_

**Example**::

    Steam.Matchmaking.CreateLobby(Steam.k_ELobbyTypePublic, 8, function(data, err)
        if err or data.m_eResult ~= Steam.k_EResultOK then
            print('Failed to create lobby')
            return
        end
        local lobbyID = data.m_ulSteamIDLobby
        Steam.Matchmaking.SetLobbyData(lobbyID, 'map', 'level_01')
        Steam.Matchmaking.SetLobbyData(lobbyID, 'mode', 'deathmatch')
    end)

.. function:: Matchmaking.DeleteLobbyData(steamIDLobby, pchKey)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param str? pchKey:
    :returns: (bool) Return value
    :SteamWorks: `DeleteLobbyData <https://partner.steamgames.com/doc/api/ISteamMatchmaking#DeleteLobbyData>`_

.. function:: Matchmaking.GetFavoriteGame(iGame)

    🤖 **Auto-generated binding**

    :param int iGame:
    :returns: (bool) Return value
    :returns: (int) ``pnAppID``
    :returns: (int) ``pnIP``
    :returns: (int) ``pnConnPort``
    :returns: (int) ``pnQueryPort``
    :returns: (int) ``punFlags``
    :returns: (int) ``pRTime32LastPlayedOnServer``
    :SteamWorks: `GetFavoriteGame <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetFavoriteGame>`_

    **Signature differences from C++ API:**

    * Parameter ``pnAppID`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``pnIP`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``pnConnPort`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``pnQueryPort`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``punFlags`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``pRTime32LastPlayedOnServer`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.

**Example**::

    local nGames = Steam.Matchmaking.GetFavoriteGameCount()
    for i = 0, nGames - 1 do
        local ok, pnAppID, _, _, _, _, _ = Steam.Matchmaking.GetFavoriteGame(i)
        print("Favorite game", i, pnAppID)
    end

.. function:: Matchmaking.GetFavoriteGameCount()

    🤖 **Auto-generated binding**

    :returns: (int) Return value
    :SteamWorks: `GetFavoriteGameCount <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetFavoriteGameCount>`_

    **Notes:**

    * See :func:`MatchMaking.GetFavoriteGame`'s example.

.. function:: Matchmaking.GetLobbyByIndex(iLobby)

    🤖 **Auto-generated binding**

    :param int iLobby:
    :returns: (uint64 - CSteamID) Return value
    :SteamWorks: `GetLobbyByIndex <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyByIndex>`_

    **Notes:**

    * See :func:`MatchMaking.RequestLobbyList`'s example.

.. function:: Matchmaking.GetLobbyChatEntry(steamIDLobby, iChatID, cubData)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param int iChatID:
    :param int? cubData: size of the buffer to allocate for ``pvData``. If ``nil`` then the buffer will be ``NULL``.
    :returns: (int) Return value
    :returns: (uint64) ``pSteamIDUser``
    :returns: (str) ``pvData``
    :returns: (int) ``peChatEntryType``
    :SteamWorks: `GetLobbyChatEntry <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyChatEntry>`_

    **Signature differences from C++ API:**

    * Parameter ``pSteamIDUser`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``pvData`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``peChatEntryType`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.

.. function:: Matchmaking.GetLobbyData(steamIDLobby, pchKey)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param str? pchKey:
    :returns: (str) Return value
    :SteamWorks: `GetLobbyData <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyData>`_

**Example**::

    local map = Steam.Matchmaking.GetLobbyData(lobbyID, 'map')
    print('Current map:', map)

.. function:: Matchmaking.GetLobbyDataByIndex(steamIDLobby, iLobbyData, cchKeyBufferSize, cchValueBufferSize)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param int iLobbyData:
    :param int? cchKeyBufferSize: size of the buffer to allocate for ``pchKey``. If ``nil`` then the buffer will be ``NULL``.
    :param int? cchValueBufferSize: size of the buffer to allocate for ``pchValue``. If ``nil`` then the buffer will be ``NULL``.
    :returns: (bool) Return value
    :returns: (str) ``pchKey``
    :returns: (str) ``pchValue``
    :SteamWorks: `GetLobbyDataByIndex <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyDataByIndex>`_

    **Signature differences from C++ API:**

    * Parameter ``pchKey`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``pchValue`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.

.. function:: Matchmaking.GetLobbyDataCount(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :returns: (int) Return value
    :SteamWorks: `GetLobbyDataCount <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyDataCount>`_

.. function:: Matchmaking.GetLobbyGameServer(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :returns: (bool) Return value
    :returns: (int) ``punGameServerIP``
    :returns: (int) ``punGameServerPort``
    :returns: (uint64) ``psteamIDGameServer``
    :SteamWorks: `GetLobbyGameServer <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyGameServer>`_

    **Signature differences from C++ API:**

    * Parameter ``punGameServerIP`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``punGameServerPort`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.
    * Parameter ``psteamIDGameServer`` is not a parameter in Lua — it is an output-only pointer in C++ and is returned as an additional return value.

**Example**::

    local hasServer, ip, port, steamID = Steam.Matchmaking.GetLobbyGameServer(lobbyID)
    if hasServer then
        connectToGameServer(ip, port)
    end

.. function:: Matchmaking.GetLobbyMemberByIndex(steamIDLobby, iMember)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param int iMember:
    :returns: (uint64 - CSteamID) Return value
    :SteamWorks: `GetLobbyMemberByIndex <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyMemberByIndex>`_

    **Notes:**

    * See :func:`MatchMaking.GetNumLobbyMembers`'s example.

.. function:: Matchmaking.GetLobbyMemberData(steamIDLobby, steamIDUser, pchKey)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param uint64 - CSteamID steamIDUser:
    :param str? pchKey:
    :returns: (str) Return value
    :SteamWorks: `GetLobbyMemberData <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyMemberData>`_

**Example**::

    local team = Steam.Matchmaking.GetLobbyMemberData(lobbyID, memberSteamID, 'team')
    print('Member team:', team)

.. function:: Matchmaking.GetLobbyMemberLimit(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :returns: (int) Return value
    :SteamWorks: `GetLobbyMemberLimit <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyMemberLimit>`_

.. function:: Matchmaking.GetLobbyOwner(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :returns: (uint64 - CSteamID) Return value
    :SteamWorks: `GetLobbyOwner <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetLobbyOwner>`_

**Example**::

    local ownerID = Steam.Matchmaking.GetLobbyOwner(lobbyID)
    local isOwner = ownerID == Steam.User.GetSteamID()

.. function:: Matchmaking.GetNumLobbyMembers(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :returns: (int) Return value
    :SteamWorks: `GetNumLobbyMembers <https://partner.steamgames.com/doc/api/ISteamMatchmaking#GetNumLobbyMembers>`_

**Example**::

    local count = Steam.Matchmaking.GetNumLobbyMembers(lobbyID)
    for i = 0, count - 1 do
        local memberID = Steam.Matchmaking.GetLobbyMemberByIndex(lobbyID, i)
        print('Member:', Steam.Friends.GetFriendPersonaName(memberID))
    end

.. function:: Matchmaking.InviteUserToLobby(steamIDLobby, steamIDInvitee)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param uint64 - CSteamID steamIDInvitee:
    :returns: (bool) Return value
    :SteamWorks: `InviteUserToLobby <https://partner.steamgames.com/doc/api/ISteamMatchmaking#InviteUserToLobby>`_

**Example**::

    Steam.Matchmaking.InviteUserToLobby(lobbyID, friendSteamID)

.. function:: Matchmaking.JoinLobby(steamIDLobby, callback)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param function callback: CallResult callback receiving struct :func:`LobbyEnter_t <Matchmaking.OnLobbyEnter>` and a boolean
    :returns: (uint64) ``SteamAPICall_t`` handle for this async call. The result is delivered via the ``callback`` parameter when :func:`Steam.RunCallbacks` is called.
    :SteamWorks: `JoinLobby <https://partner.steamgames.com/doc/api/ISteamMatchmaking#JoinLobby>`_

**Example**::

    Steam.Matchmaking.JoinLobby(lobbyID, function(data, err)
        if err or data.m_EChatRoomEnterResponse ~= 1 then
            print('Failed to join lobby')
        else
            print('Joined lobby:', tostring(data.m_ulSteamIDLobby))
        end
    end)

.. function:: Matchmaking.LeaveLobby(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :SteamWorks: `LeaveLobby <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LeaveLobby>`_

**Example**::

    Steam.Matchmaking.LeaveLobby(lobbyID)

.. function:: Matchmaking.RemoveFavoriteGame(nAppID, nIP, nConnPort, nQueryPort, unFlags)

    🤖 **Auto-generated binding**

    :param int - AppId_t nAppID:
    :param int nIP:
    :param int nConnPort:
    :param int nQueryPort:
    :param int unFlags:
    :returns: (bool) Return value
    :SteamWorks: `RemoveFavoriteGame <https://partner.steamgames.com/doc/api/ISteamMatchmaking#RemoveFavoriteGame>`_

.. function:: Matchmaking.RequestLobbyData(steamIDLobby)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :returns: (bool) Return value
    :SteamWorks: `RequestLobbyData <https://partner.steamgames.com/doc/api/ISteamMatchmaking#RequestLobbyData>`_

.. function:: Matchmaking.RequestLobbyList(callback)

    🤖 **Auto-generated binding**

    :param function callback: CallResult callback receiving struct :func:`LobbyMatchList_t <Matchmaking.OnLobbyMatchList>` and a boolean
    :returns: (uint64) ``SteamAPICall_t`` handle for this async call. The result is delivered via the ``callback`` parameter when :func:`Steam.RunCallbacks` is called.
    :SteamWorks: `RequestLobbyList <https://partner.steamgames.com/doc/api/ISteamMatchmaking#RequestLobbyList>`_

**Example**::

    Steam.Matchmaking.AddRequestLobbyListStringFilter('map', 'level_01', Steam.k_ELobbyComparisonEqualToOrLessThan)
    Steam.Matchmaking.AddRequestLobbyListResultCountFilter(20)
    Steam.Matchmaking.RequestLobbyList(function(data, err)
        if not err then
            for i = 0, data.m_nLobbiesMatching - 1 do
                local id = Steam.Matchmaking.GetLobbyByIndex(i)
                local map = Steam.Matchmaking.GetLobbyData(id, 'map')
                print('Lobby: ' .. map .. ' (' .. Steam.Matchmaking.GetNumLobbyMembers(id) .. ' players)')
            end
        end
    end)

.. function:: Matchmaking.SendLobbyChatMsg(steamIDLobby, pvMsgBody, cubMsgBody)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param str? pvMsgBody:
    :param int cubMsgBody: size of the input array ``pvMsgBody``
    :returns: (bool) Return value
    :SteamWorks: `SendLobbyChatMsg <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SendLobbyChatMsg>`_

**Example**::

    local msg = 'Ready!'
    Steam.Matchmaking.SendLobbyChatMsg(lobbyID, msg, #msg)

.. function:: Matchmaking.SetLinkedLobby(steamIDLobby, steamIDLobbyDependent)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param uint64 - CSteamID steamIDLobbyDependent:
    :returns: (bool) Return value
    :SteamWorks: `SetLinkedLobby <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLinkedLobby>`_

.. function:: Matchmaking.SetLobbyData(steamIDLobby, pchKey, pchValue)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param str? pchKey:
    :param str? pchValue:
    :returns: (bool) Return value
    :SteamWorks: `SetLobbyData <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyData>`_

**Example**::

    Steam.Matchmaking.SetLobbyData(lobbyID, 'map', 'dungeon_01')
    Steam.Matchmaking.SetLobbyData(lobbyID, 'players', tostring(playerCount))

.. function:: Matchmaking.SetLobbyGameServer(steamIDLobby, unGameServerIP, unGameServerPort, steamIDGameServer)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param int unGameServerIP:
    :param int unGameServerPort:
    :param uint64 - CSteamID steamIDGameServer:
    :SteamWorks: `SetLobbyGameServer <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyGameServer>`_

**Example**::

    Steam.Matchmaking.SetLobbyGameServer(lobbyID, serverIP, serverPort, Steam.GameServer.GetSteamID())

.. function:: Matchmaking.SetLobbyJoinable(steamIDLobby, bLobbyJoinable)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param bool bLobbyJoinable:
    :returns: (bool) Return value
    :SteamWorks: `SetLobbyJoinable <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyJoinable>`_

**Example**::

    -- Lock the lobby when the game starts
    Steam.Matchmaking.SetLobbyJoinable(lobbyID, false)

.. function:: Matchmaking.SetLobbyMemberData(steamIDLobby, pchKey, pchValue)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param str? pchKey:
    :param str? pchValue:
    :SteamWorks: `SetLobbyMemberData <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyMemberData>`_

**Example**::

    -- Set per-player data visible to other lobby members
    Steam.Matchmaking.SetLobbyMemberData(lobbyID, 'team', 'blue')
    Steam.Matchmaking.SetLobbyMemberData(lobbyID, 'ready', '1')

.. function:: Matchmaking.SetLobbyMemberLimit(steamIDLobby, cMaxMembers)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param int cMaxMembers:
    :returns: (bool) Return value
    :SteamWorks: `SetLobbyMemberLimit <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyMemberLimit>`_

.. function:: Matchmaking.SetLobbyOwner(steamIDLobby, steamIDNewOwner)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param uint64 - CSteamID steamIDNewOwner:
    :returns: (bool) Return value
    :SteamWorks: `SetLobbyOwner <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyOwner>`_

.. function:: Matchmaking.SetLobbyType(steamIDLobby, eLobbyType)

    🤖 **Auto-generated binding**

    :param uint64 - CSteamID steamIDLobby:
    :param int - ELobbyType eLobbyType:
    :returns: (bool) Return value
    :SteamWorks: `SetLobbyType <https://partner.steamgames.com/doc/api/ISteamMatchmaking#SetLobbyType>`_


Callbacks
---------

.. function:: Matchmaking.OnFavoritesListChanged

    Callback for `FavoritesListChanged_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#FavoritesListChanged_t>`_

    **callback(data)** receives:

    * **data.m_nIP** *(int)*
    * **data.m_nQueryPort** *(int)*
    * **data.m_nConnPort** *(int)*
    * **data.m_nAppID** *(int)*
    * **data.m_nFlags** *(int)*
    * **data.m_bAdd** *(bool)*
    * **data.m_unAccountId** *(int - AccountID_t)*

.. function:: Matchmaking.OnLobbyInvite

    Callback for `LobbyInvite_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyInvite_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDUser** *(uint64)*
    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_ulGameID** *(uint64)*

**Example**::

    function Steam.Matchmaking.OnLobbyInvite(data)
        local name = Steam.Friends.GetFriendPersonaName(data.m_ulSteamIDUser)
        print(name .. ' invited you to a lobby')
        showJoinPrompt(data.m_ulSteamIDLobby)
    end

.. function:: Matchmaking.OnLobbyEnter

    Callback for `LobbyEnter_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyEnter_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_rgfChatPermissions** *(int)*
    * **data.m_bLocked** *(bool)*
    * **data.m_EChatRoomEnterResponse** *(int)*

**Example**::

    function Steam.Matchmaking.OnLobbyEnter(data)
        if data.m_EChatRoomEnterResponse == 1 then
            print('Entered lobby:', tostring(data.m_ulSteamIDLobby))
            updateLobbyUI(data.m_ulSteamIDLobby)
        end
    end

.. function:: Matchmaking.OnLobbyDataUpdate

    Callback for `LobbyDataUpdate_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyDataUpdate_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_ulSteamIDMember** *(uint64)*
    * **data.m_bSuccess** *(int)*

**Example**::

    function Steam.Matchmaking.OnLobbyDataUpdate(data)
        if data.m_bSuccess ~= 0 then
            local map = Steam.Matchmaking.GetLobbyData(data.m_ulSteamIDLobby, 'map')
            print('Lobby data updated, map:', map)
        end
    end

.. function:: Matchmaking.OnLobbyChatUpdate

    Callback for `LobbyChatUpdate_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyChatUpdate_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_ulSteamIDUserChanged** *(uint64)*
    * **data.m_ulSteamIDMakingChange** *(uint64)*
    * **data.m_rgfChatMemberStateChange** *(int)*

**Example**::

    function Steam.Matchmaking.OnLobbyChatUpdate(data)
        local count = Steam.Matchmaking.GetNumLobbyMembers(data.m_ulSteamIDLobby)
        print('Lobby membership changed, now', count, 'players')
    end

.. function:: Matchmaking.OnLobbyChatMsg

    Callback for `LobbyChatMsg_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyChatMsg_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_ulSteamIDUser** *(uint64)*
    * **data.m_eChatEntryType** *(int)*
    * **data.m_iChatID** *(int)*

**Example**::

    function Steam.Matchmaking.OnLobbyChatMsg(data)
        local msg, chatType = Steam.Matchmaking.GetLobbyChatEntry(data.m_ulSteamIDLobby, data.m_iChatID, 512)
        if msg then
            local name = Steam.Friends.GetFriendPersonaName(data.m_ulSteamIDUser)
            print(name .. ': ' .. msg)
        end
    end

.. function:: Matchmaking.OnLobbyGameCreated

    Callback for `LobbyGameCreated_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyGameCreated_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_ulSteamIDGameServer** *(uint64)*
    * **data.m_unIP** *(int)*
    * **data.m_usPort** *(int)*

**Example**::

    function Steam.Matchmaking.OnLobbyGameCreated(data)
        print('Game server created:', data.m_ulSteamIDGameServer)
        connectToGameServer(data.m_unIP, data.m_usPort)
    end

.. function:: Matchmaking.OnLobbyMatchList

    Callback for `LobbyMatchList_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyMatchList_t>`_

    **callback(data)** receives:

    * **data.m_nLobbiesMatching** *(int)*

.. function:: Matchmaking.OnLobbyKicked

    Callback for `LobbyKicked_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyKicked_t>`_

    **callback(data)** receives:

    * **data.m_ulSteamIDLobby** *(uint64)*
    * **data.m_ulSteamIDAdmin** *(uint64)*
    * **data.m_bKickedDueToDisconnect** *(int)*

.. function:: Matchmaking.OnLobbyCreated

    Callback for `LobbyCreated_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#LobbyCreated_t>`_

    **callback(data)** receives:

    * **data.m_eResult** *(int - EResult)*
    * **data.m_ulSteamIDLobby** *(uint64)*

.. function:: Matchmaking.OnFavoritesListAccountsUpdated

    Callback for `FavoritesListAccountsUpdated_t <https://partner.steamgames.com/doc/api/ISteamMatchmaking#FavoritesListAccountsUpdated_t>`_

    **callback(data)** receives:

    * **data.m_eResult** *(int - EResult)*