// Token: 0x0600096D RID: 2413 RVA: 0x0004553C File Offset: 0x0004373C
    private void RequestFriendGames()
    {
        this.m_friendServers.Clear();
        this.m_requestedFriendGames.Clear();
        int num = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);

        if (num == -1)
        {
            ZLog.Log("GetFriendCount returned -1, the current user is not logged in.");
            num = 0;
        }
        for (int i = 0; i < num; i++)
        {
            CSteamID         friendByIndex     = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
            string           friendPersonaName = SteamFriends.GetFriendPersonaName(friendByIndex);
            FriendGameInfo_t friendGameInfo_t;
            if (SteamFriends.GetFriendGamePlayed(friendByIndex, out friendGameInfo_t) && friendGameInfo_t.m_gameID == (CGameID)((ulong)SteamManager.APP_ID) && friendGameInfo_t.m_steamIDLobby != CSteamID.Nil)
            {
                ZLog.Log("Friend is in our game");
                this.m_requestedFriendGames.Add(new KeyValuePair <CSteamID, string>(friendGameInfo_t.m_steamIDLobby, friendPersonaName));
                SteamMatchmaking.RequestLobbyData(friendGameInfo_t.m_steamIDLobby);
            }
        }
        this.m_serverListRevision++;
    }
示例#2
0
        public static void FindFriendLobbies(Action <bool> OnFind)
        {
            s_OnFindLobbies       = OnFind;
            s_nLobbiesFound       = 0;
            s_nFriendLobbiesFound = 0;

            //if ( SteamMatchmaking() == 0 ) return;
            InteropHelp.TestIfAvailableClient();

            int cFriends = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);

            for (int i = 0; i < cFriends; i++)
            {
                FriendGameInfo_t friendGameInfo;
                CSteamID         steamIDFriend = (CSteamID)SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
                if (SteamFriends.GetFriendGamePlayed(steamIDFriend, out friendGameInfo) && friendGameInfo.m_steamIDLobby.IsValid())
                {
                    m_friendLobbies[s_nFriendLobbiesFound++] = friendGameInfo.m_steamIDLobby;
                    SteamMatchmaking.RequestLobbyData(friendGameInfo.m_steamIDLobby);
                    //int cap = SteamMatchmaking().GetLobbyMemberLimit( friendGameInfo.m_steamIDLobby );
                    //Console.WriteLine("Found friend lobby with capacity {0}", cap);
                }
            }

            if (s_OnFindLobbies != null)
            {
                s_OnFindLobbies(false);
            }
        }
示例#3
0
        private void Update()
        {
            if (Time.time > nextListUpdateTime)
            {
                // Refresh lobbies from steam
                GetAvailableLobbyList();

                // TODO:
                // Is re-requesting with the same filters enough and simply not add the server if it is already in the list?
                // What should happen to servers that are not returned in the new request? Should they be removed?

                // TODO: Might worth extracting the 20.0f into a const or a field to be configured via the inspector
                //       Is refreshing the list every 20ish seconds good enough?
                nextListUpdateTime = Time.time + 20.0f + UnityEngine.Random.Range(0.0f, 1.0f);
            }

            foreach (var server in serverList)
            {
                if (Time.time > server.NextUpdate)
                {
                    // Time to re-request the server information
                    SteamMatchmaking.RequestLobbyData(server.SteamId);

                    // TODO: Might worth extracting the 5.0f into a const or a field to be configured via the inspector
                    //       Is re-requesting the server/lobby info every 5 seconds good enough? Should it be less frequent?
                    //
                    server.NextUpdate = Time.time + 5.0f + UnityEngine.Random.Range(0.0f, 1.0f);
                }
            }
        }
示例#4
0
        public static void RequestLobbies()
        {
            if (!SteamManager.Initialized)
            {
                Logger.Error("CONNECTION FAILED");
                return;
            }
            Logger.Debug($"Requesting list of all lobbies from steam");

            LobbyData.Clear();
            MultiplayerListing.refreshLobbyList();

            SteamMatchmaking.AddRequestLobbyListFilterSlotsAvailable(1);
            SteamMatchmaking.AddRequestLobbyListStringFilter("version", PACKET_VERSION, ELobbyComparison.k_ELobbyComparisonEqual);
            SteamAPICall_t apiCall = SteamMatchmaking.RequestLobbyList();

            OnLobbyMatchListCallResult.Set(apiCall);

            int cFriends = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);

            for (int i = 0; i < cFriends; i++)
            {
                FriendGameInfo_t friendGameInfo;
                CSteamID         steamIDFriend = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate); SteamFriends.GetFriendGamePlayed(steamIDFriend, out friendGameInfo);
                if (friendGameInfo.m_gameID == GetGameID() && friendGameInfo.m_steamIDLobby.IsValid())
                {
                    SteamMatchmaking.RequestLobbyData(friendGameInfo.m_steamIDLobby);
                }
            }
        }
        private static GameServer[] HandleGameLobbies(LobbyMatchList_t param)
        {
            var lobbies = new List <GameServer>();

            for (int i = 0; i < param.m_nLobbiesMatching; i++)
            {
                var lobbyId = SteamMatchmaking.GetLobbyByIndex(i);

                if (SteamMatchmaking.RequestLobbyData(lobbyId))
                {
                    var indicator = SteamMatchmaking.GetLobbyData(lobbyId, LobbyDataKeys.STEAM_SPY_INDICATOR);

                    if (!indicator.IsNullOrEmpty() && indicator == SteamConstants.INDICATOR)
                    {
                        var ownerId = SteamMatchmaking.GetLobbyData(lobbyId, LobbyDataKeys.HOST_STEAM_ID);
                        var id      = ownerId.ParseToUlongOrDefault();

                        if (id == 0)
                        {
                            continue;
                        }

                        var ownerSteamId = new CSteamID(id);

                        if (ownerSteamId == SteamUser.GetSteamID())
                        {
                            continue;
                        }

                        var server = new GameServer();

                        server.HostSteamId = ownerSteamId;

                        var rowCount = SteamMatchmaking.GetLobbyDataCount(lobbyId);

                        string key;
                        string value;

                        for (int k = 0; k < rowCount; k++)
                        {
                            if (SteamMatchmaking.GetLobbyDataByIndex(lobbyId, k, out key, 100, out value, 100))
                            {
                                server.Set(key, value);
                            }
                        }

                        if (!server.HasPlayers)
                        {
                            continue;
                        }

                        lobbies.Add(server);
                    }
                }
            }

            return(lobbies.ToArray());
        }
 void OnGetLobbiesList(LobbyMatchList_t result)
 {
     for (int i = 0; i < result.m_nLobbiesMatching; ++i)
     {
         CSteamID lobbyId = SteamMatchmaking.GetLobbyByIndex(i);
         lobbyIDS.Add(lobbyId);
         SteamMatchmaking.RequestLobbyData(lobbyId);
     }
 }
示例#7
0
 /// <summary>
 /// Handle the RequestLobbyList Steam API callback
 /// </summary>
 /// <param name="result">The <see cref="LobbyMatchList_t"/> result set</param>
 private void OnLobbyListRequested(LobbyMatchList_t result)
 {
     for (int i = 0; i < result.m_nLobbiesMatching; i++)
     {
         var lobbyId = SteamMatchmaking.GetLobbyByIndex(i);
         AddServer(lobbyId);
         SteamMatchmaking.RequestLobbyData(lobbyId);
     }
 }
示例#8
0
 void OnGetLobbiesList(LobbyMatchList_t result)
 {
     //Debug.Log("Found " + result.m_nLobbiesMatching + " lobbies!");
     for (int i = 0; i < result.m_nLobbiesMatching; i++)
     {
         CSteamID lobbyID = SteamMatchmaking.GetLobbyByIndex(i);
         lobbyIDS.Add(lobbyID);
         SteamMatchmaking.RequestLobbyData(lobbyID);
     }
 }
示例#9
0
 private void RequestLobbyData(CSteamID lobbyID)
 {
     stats.RequestLobbyDataCount++;
     if (SteamMatchmaking.RequestLobbyData(lobbyID))
     {
         SetUpdatePending(lobbyID.m_SteamID, true);
     }
     else
     {
         MarkLobbyDead(lobbyID.m_SteamID);
     }
 }
示例#10
0
        public override void RequestFriendLobbyData()
        {
            EFriendFlags flags = EFriendFlags.k_EFriendFlagImmediate;
            int          count = SteamFriends.GetFriendCount(flags);

            for (int i = 0; i < count; i++)
            {
                if (SteamFriends.GetFriendGamePlayed(SteamFriends.GetFriendByIndex(i, flags), out FriendGameInfo_t gameInfo) && !(gameInfo.m_gameID.AppID() != SteamUtils.GetAppID()))
                {
                    SteamMatchmaking.RequestLobbyData(gameInfo.m_steamIDLobby);
                }
            }
        }
    // Token: 0x06000966 RID: 2406 RVA: 0x00045248 File Offset: 0x00043448
    public void QueueLobbyJoin(CSteamID lobbyID)
    {
        uint     num;
        ushort   num2;
        CSteamID csteamID;

        if (SteamMatchmaking.GetLobbyGameServer(lobbyID, out num, out num2, out csteamID))
        {
            ZLog.Log("  hostid: " + csteamID);
            this.m_joinUserID      = csteamID;
            this.m_queuedJoinLobby = CSteamID.Nil;
            return;
        }
        ZLog.Log("Failed to get lobby data for lobby " + lobbyID + ", requesting lobby data");
        this.m_queuedJoinLobby = lobbyID;
        SteamMatchmaking.RequestLobbyData(lobbyID);
    }
示例#12
0
        public static void RequestAvailableLobbies()
        {
            if (!SteamManager.Initialized)
            {
                Logger.Error("CONNECTION FAILED");
                return;
            }
            LobbyData.Clear();
            MultiplayerListing.refreshLobbyList();
            int cFriends = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);

            for (int i = 0; i < cFriends; i++)
            {
                FriendGameInfo_t friendGameInfo;
                CSteamID         steamIDFriend = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate); SteamFriends.GetFriendGamePlayed(steamIDFriend, out friendGameInfo);
                if (friendGameInfo.m_gameID == GetGameID() && friendGameInfo.m_steamIDLobby.IsValid())
                {
                    SteamMatchmaking.RequestLobbyData(friendGameInfo.m_steamIDLobby);
                }
            }
        }
示例#13
0
    private void FindFriendLobbies()
    {
        lobbyDisplay.Clear();
        lobbyIDS.Clear();
        lobbyDisplay.Add(new KeyValuePair <string, CSteamID>("Back", (CSteamID)0));
        lobbyDisplay.Add(new KeyValuePair <string, CSteamID>("Refresh", (CSteamID)0));
        initializedStatus = 2;

        int steamFriends = SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate);

        for (int i = 0; i < steamFriends; i++)
        {
            FriendGameInfo_t friendGameInfo;
            CSteamID         steamIDFriend = SteamFriends.GetFriendByIndex(i, EFriendFlags.k_EFriendFlagImmediate);
            if (SteamFriends.GetFriendGamePlayed(steamIDFriend, out friendGameInfo) && friendGameInfo.m_steamIDLobby.IsValid())
            {
                lobbyIDS.Add(friendGameInfo.m_steamIDLobby);
                SteamMatchmaking.RequestLobbyData(friendGameInfo.m_steamIDLobby);
            }
        }
    }
示例#14
0
    public void RenderOnGUI()
    {
        GUILayout.BeginArea(new Rect(Screen.width - 200, 0, 200, Screen.height));
        GUILayout.Label("Variables:");
        GUILayout.Label("m_Lobby: " + m_Lobby);
        GUILayout.EndArea();

        GUILayout.BeginVertical("box");
        m_ScrollPos = GUILayout.BeginScrollView(m_ScrollPos, GUILayout.Width(Screen.width - 215), GUILayout.Height(Screen.height - 33));

        GUILayout.Label("GetFavoriteGameCount() : " + SteamMatchmaking.GetFavoriteGameCount());

        {
            AppId_t AppID;
            uint    IP;
            ushort  ConnPort;
            ushort  QueryPort;
            uint    Flags;
            uint    LastPlayedOnServer;
            bool    ret = SteamMatchmaking.GetFavoriteGame(0, out AppID, out IP, out ConnPort, out QueryPort, out Flags, out LastPlayedOnServer);
            GUILayout.Label("GetFavoriteGame(0, out AppID, out IP, out ConnPort, out QueryPort, out Flags, out LastPlayedOnServer) : " + ret + " -- " + AppID + " -- " + IP + " -- " + ConnPort + " -- " + QueryPort + " -- " + Flags + " -- " + LastPlayedOnServer);
        }

        if (GUILayout.Button("AddFavoriteGame(TestConstants.Instance.k_AppId_TeamFortress2, TestConstants.k_IpAddress208_78_165_233_uint, TestConstants.k_Port27015, TestConstants.k_Port27015, Constants.k_unFavoriteFlagFavorite, CurrentUnixTime)"))
        {
            uint CurrentUnixTime = (uint)(System.DateTime.UtcNow.Subtract(new System.DateTime(1970, 1, 1))).TotalSeconds;
            int  ret             = SteamMatchmaking.AddFavoriteGame(TestConstants.Instance.k_AppId_TeamFortress2, TestConstants.k_IpAddress208_78_165_233_uint, TestConstants.k_Port27015, TestConstants.k_Port27015, Constants.k_unFavoriteFlagFavorite, CurrentUnixTime);
            print("SteamMatchmaking.AddFavoriteGame(" + TestConstants.Instance.k_AppId_TeamFortress2 + ", " + TestConstants.k_IpAddress208_78_165_233_uint + ", " + TestConstants.k_Port27015 + ", " + TestConstants.k_Port27015 + ", " + Constants.k_unFavoriteFlagFavorite + ", " + CurrentUnixTime + ") : " + ret);
        }

        if (GUILayout.Button("RemoveFavoriteGame(TestConstants.Instance.k_AppId_TeamFortress2, TestConstants.k_IpAddress208_78_165_233_uint, TestConstants.k_Port27015, TestConstants.k_Port27015, Constants.k_unFavoriteFlagFavorite)"))
        {
            bool ret = SteamMatchmaking.RemoveFavoriteGame(TestConstants.Instance.k_AppId_TeamFortress2, TestConstants.k_IpAddress208_78_165_233_uint, TestConstants.k_Port27015, TestConstants.k_Port27015, Constants.k_unFavoriteFlagFavorite);
            print("SteamMatchmaking.RemoveFavoriteGame(" + TestConstants.Instance.k_AppId_TeamFortress2 + ", " + TestConstants.k_IpAddress208_78_165_233_uint + ", " + TestConstants.k_Port27015 + ", " + TestConstants.k_Port27015 + ", " + Constants.k_unFavoriteFlagFavorite + ") : " + ret);
        }

        if (GUILayout.Button("RequestLobbyList()"))
        {
            SteamAPICall_t handle = SteamMatchmaking.RequestLobbyList();
            OnLobbyMatchListCallResult.Set(handle);
            print("SteamMatchmaking.RequestLobbyList() : " + handle);
        }

        if (GUILayout.Button("AddRequestLobbyListStringFilter(\"SomeStringKey\", \"SomeValue\", ELobbyComparison.k_ELobbyComparisonNotEqual)"))
        {
            SteamMatchmaking.AddRequestLobbyListStringFilter("SomeStringKey", "SomeValue", ELobbyComparison.k_ELobbyComparisonNotEqual);
            print("SteamMatchmaking.AddRequestLobbyListStringFilter(" + "\"SomeStringKey\"" + ", " + "\"SomeValue\"" + ", " + ELobbyComparison.k_ELobbyComparisonNotEqual + ")");
        }

        if (GUILayout.Button("AddRequestLobbyListNumericalFilter(\"SomeIntKey\", 0, ELobbyComparison.k_ELobbyComparisonNotEqual)"))
        {
            SteamMatchmaking.AddRequestLobbyListNumericalFilter("SomeIntKey", 0, ELobbyComparison.k_ELobbyComparisonNotEqual);
            print("SteamMatchmaking.AddRequestLobbyListNumericalFilter(" + "\"SomeIntKey\"" + ", " + 0 + ", " + ELobbyComparison.k_ELobbyComparisonNotEqual + ")");
        }

        if (GUILayout.Button("AddRequestLobbyListNearValueFilter(\"SomeIntKey\", 0)"))
        {
            SteamMatchmaking.AddRequestLobbyListNearValueFilter("SomeIntKey", 0);
            print("SteamMatchmaking.AddRequestLobbyListNearValueFilter(" + "\"SomeIntKey\"" + ", " + 0 + ")");
        }

        if (GUILayout.Button("AddRequestLobbyListFilterSlotsAvailable(3)"))
        {
            SteamMatchmaking.AddRequestLobbyListFilterSlotsAvailable(3);
            print("SteamMatchmaking.AddRequestLobbyListFilterSlotsAvailable(" + 3 + ")");
        }

        if (GUILayout.Button("AddRequestLobbyListDistanceFilter(ELobbyDistanceFilter.k_ELobbyDistanceFilterWorldwide)"))
        {
            SteamMatchmaking.AddRequestLobbyListDistanceFilter(ELobbyDistanceFilter.k_ELobbyDistanceFilterWorldwide);
            print("SteamMatchmaking.AddRequestLobbyListDistanceFilter(" + ELobbyDistanceFilter.k_ELobbyDistanceFilterWorldwide + ")");
        }

        if (GUILayout.Button("AddRequestLobbyListResultCountFilter(1)"))
        {
            SteamMatchmaking.AddRequestLobbyListResultCountFilter(1);
            print("SteamMatchmaking.AddRequestLobbyListResultCountFilter(" + 1 + ")");
        }

        if (GUILayout.Button("AddRequestLobbyListCompatibleMembersFilter((CSteamID)0)"))
        {
            SteamMatchmaking.AddRequestLobbyListCompatibleMembersFilter((CSteamID)0);
            print("SteamMatchmaking.AddRequestLobbyListCompatibleMembersFilter(" + (CSteamID)0 + ")");
        }

        if (GUILayout.Button("GetLobbyByIndex(0)"))
        {
            m_Lobby = SteamMatchmaking.GetLobbyByIndex(0);
            print("SteamMatchmaking.GetLobbyByIndex(" + 0 + ") : " + m_Lobby);
        }

        if (GUILayout.Button("CreateLobby(ELobbyType.k_ELobbyTypePublic, 1)"))
        {
            SteamAPICall_t handle = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 1);
            OnLobbyCreatedCallResult.Set(handle);
            print("SteamMatchmaking.CreateLobby(" + ELobbyType.k_ELobbyTypePublic + ", " + 1 + ") : " + handle);
        }

        if (GUILayout.Button("JoinLobby(m_Lobby)"))
        {
            SteamAPICall_t handle = SteamMatchmaking.JoinLobby(m_Lobby);
            OnLobbyEnterCallResult.Set(handle);
            print("SteamMatchmaking.JoinLobby(" + m_Lobby + ") : " + handle);
        }

        if (GUILayout.Button("LeaveLobby(m_Lobby)"))
        {
            SteamMatchmaking.LeaveLobby(m_Lobby);
            m_Lobby = CSteamID.Nil;
            print("SteamMatchmaking.LeaveLobby(" + m_Lobby + ")");
        }

        if (GUILayout.Button("InviteUserToLobby(m_Lobby, SteamUser.GetSteamID())"))
        {
            bool ret = SteamMatchmaking.InviteUserToLobby(m_Lobby, SteamUser.GetSteamID());
            print("SteamMatchmaking.InviteUserToLobby(" + m_Lobby + ", " + SteamUser.GetSteamID() + ") : " + ret);
        }

        GUILayout.Label("GetNumLobbyMembers(m_Lobby) : " + SteamMatchmaking.GetNumLobbyMembers(m_Lobby));

        GUILayout.Label("GetLobbyMemberByIndex(m_Lobby, 0) : " + SteamMatchmaking.GetLobbyMemberByIndex(m_Lobby, 0));

        GUILayout.Label("GetLobbyData(m_Lobby, \"name\") : " + SteamMatchmaking.GetLobbyData(m_Lobby, "name"));

        if (GUILayout.Button("SetLobbyData(m_Lobby, \"name\", \"Test Lobby!\")"))
        {
            bool ret = SteamMatchmaking.SetLobbyData(m_Lobby, "name", "Test Lobby!");
            print("SteamMatchmaking.SetLobbyData(" + m_Lobby + ", " + "\"name\"" + ", " + "\"Test Lobby!\"" + ") : " + ret);
        }

        GUILayout.Label("GetLobbyDataCount(m_Lobby) : " + SteamMatchmaking.GetLobbyDataCount(m_Lobby));

        {
            string Key;
            string Value;
            bool   ret = SteamMatchmaking.GetLobbyDataByIndex(m_Lobby, 0, out Key, 255, out Value, 255);
            GUILayout.Label("GetLobbyDataByIndex(m_Lobby, 0, out Key, 255, out Value, 255) : " + ret + " -- " + Key + " -- " + Value);
        }

        if (GUILayout.Button("DeleteLobbyData(m_Lobby, \"name\")"))
        {
            bool ret = SteamMatchmaking.DeleteLobbyData(m_Lobby, "name");
            print("SteamMatchmaking.DeleteLobbyData(" + m_Lobby + ", " + "\"name\"" + ") : " + ret);
        }

        GUILayout.Label("GetLobbyMemberData(m_Lobby, SteamUser.GetSteamID(), \"test\") : " + SteamMatchmaking.GetLobbyMemberData(m_Lobby, SteamUser.GetSteamID(), "test"));

        if (GUILayout.Button("SetLobbyMemberData(m_Lobby, \"test\", \"This is a test Key!\")"))
        {
            SteamMatchmaking.SetLobbyMemberData(m_Lobby, "test", "This is a test Key!");
            print("SteamMatchmaking.SetLobbyMemberData(" + m_Lobby + ", " + "\"test\"" + ", " + "\"This is a test Key!\"" + ")");
        }

        if (GUILayout.Button("SendLobbyChatMsg(m_Lobby, MsgBody, MsgBody.Length)"))
        {
            byte[] MsgBody = System.Text.Encoding.UTF8.GetBytes("Test Message!");
            bool   ret     = SteamMatchmaking.SendLobbyChatMsg(m_Lobby, MsgBody, MsgBody.Length);
            print("SteamMatchmaking.SendLobbyChatMsg(" + m_Lobby + ", " + MsgBody + ", " + MsgBody.Length + ") : " + ret);
        }

        //SteamMatchmaking.GetLobbyChatEntry() // Only called from within OnLobbyChatMsg!

        if (GUILayout.Button("RequestLobbyData(m_Lobby)"))
        {
            bool ret = SteamMatchmaking.RequestLobbyData(m_Lobby);
            print("SteamMatchmaking.RequestLobbyData(" + m_Lobby + ") : " + ret);
        }

        if (GUILayout.Button("SetLobbyGameServer(m_Lobby, TestConstants.k_IpAddress127_0_0_1_uint, TestConstants.k_Port27015, CSteamID.NonSteamGS)"))
        {
            SteamMatchmaking.SetLobbyGameServer(m_Lobby, TestConstants.k_IpAddress127_0_0_1_uint, TestConstants.k_Port27015, CSteamID.NonSteamGS);
            print("SteamMatchmaking.SetLobbyGameServer(" + m_Lobby + ", " + TestConstants.k_IpAddress127_0_0_1_uint + ", " + TestConstants.k_Port27015 + ", " + CSteamID.NonSteamGS + ")");
        }

        {
            uint     GameServerIP;
            ushort   GameServerPort;
            CSteamID SteamIDGameServer;
            bool     ret = SteamMatchmaking.GetLobbyGameServer(m_Lobby, out GameServerIP, out GameServerPort, out SteamIDGameServer);
            GUILayout.Label("GetLobbyGameServer(m_Lobby, out GameServerIP, out GameServerPort, out SteamIDGameServer) : " + ret + " -- " + GameServerIP + " -- " + GameServerPort + " -- " + SteamIDGameServer);
        }

        if (GUILayout.Button("SetLobbyMemberLimit(m_Lobby, 6)"))
        {
            bool ret = SteamMatchmaking.SetLobbyMemberLimit(m_Lobby, 6);
            print("SteamMatchmaking.SetLobbyMemberLimit(" + m_Lobby + ", " + 6 + ") : " + ret);
        }

        GUILayout.Label("GetLobbyMemberLimit(m_Lobby) : " + SteamMatchmaking.GetLobbyMemberLimit(m_Lobby));

        if (GUILayout.Button("SetLobbyType(m_Lobby, ELobbyType.k_ELobbyTypePublic)"))
        {
            bool ret = SteamMatchmaking.SetLobbyType(m_Lobby, ELobbyType.k_ELobbyTypePublic);
            print("SteamMatchmaking.SetLobbyType(" + m_Lobby + ", " + ELobbyType.k_ELobbyTypePublic + ") : " + ret);
        }

        if (GUILayout.Button("SetLobbyJoinable(m_Lobby, true)"))
        {
            bool ret = SteamMatchmaking.SetLobbyJoinable(m_Lobby, true);
            print("SteamMatchmaking.SetLobbyJoinable(" + m_Lobby + ", " + true + ") : " + ret);
        }

        if (GUILayout.Button("GetLobbyOwner(m_Lobby)"))
        {
            CSteamID ret = SteamMatchmaking.GetLobbyOwner(m_Lobby);
            print("SteamMatchmaking.GetLobbyOwner(" + m_Lobby + ") : " + ret);
        }

        if (GUILayout.Button("SetLobbyOwner(m_Lobby, SteamUser.GetSteamID())"))
        {
            bool ret = SteamMatchmaking.SetLobbyOwner(m_Lobby, SteamUser.GetSteamID());
            print("SteamMatchmaking.SetLobbyOwner(" + m_Lobby + ", " + SteamUser.GetSteamID() + ") : " + ret);
        }

        if (GUILayout.Button("SetLinkedLobby(m_Lobby, m_Lobby)"))
        {
            bool ret = SteamMatchmaking.SetLinkedLobby(m_Lobby, m_Lobby);
            print("SteamMatchmaking.SetLinkedLobby(" + m_Lobby + ", " + m_Lobby + ") : " + ret);
        }

        //SteamMatchmaking.CheckForPSNGameBootInvite() // PS3 Only.

        GUILayout.EndScrollView();
        GUILayout.EndVertical();
    }
    public void RenderOnGUI()
    {
        //GUILayout.BeginArea(new Rect(Screen.width - 120, 0, 120, Screen.height));
        Console.WriteLine("Variables:");
        Console.WriteLine("m_Lobby: " + m_Lobby);
        //GUILayout.EndArea();

        Console.WriteLine("GetFavoriteGameCount() : " + SteamMatchmaking.GetFavoriteGameCount());

        {
            AppId_t AppID;
            uint    IP;
            ushort  ConnPort;
            ushort  QueryPort;
            uint    Flags;
            uint    LastPlayedOnServer;
            bool    ret = SteamMatchmaking.GetFavoriteGame(0, out AppID, out IP, out ConnPort, out QueryPort, out Flags, out LastPlayedOnServer);
            Console.WriteLine("GetFavoriteGame(0, out AppID, out IP, out ConnPort, out QueryPort, out Flags, out LastPlayedOnServer) : " + ret + " -- " + AppID + " -- " + IP + " -- " + ConnPort + " -- " + QueryPort + " -- " + Flags + " -- " + LastPlayedOnServer);
        }

        // 3494815209 = 208.78.165.233 = Valve Payload Server (Virginia srcds150 #1)
        //if (GUILayout.Button("AddFavoriteGame((AppId_t)480, 3494815209, 27015, 27015, Constants.k_unFavoriteFlagFavorite, CurrentUnixTime"))
        {
            uint CurrentUnixTime = (uint)(System.DateTime.UtcNow.Subtract(new System.DateTime(1970, 1, 1))).TotalSeconds;
            Console.WriteLine("SteamMatchmaking.AddFavoriteGame(" + (AppId_t)480 + ", 3494815209, 27015, 27015, Constants.k_unFavoriteFlagFavorite, " + CurrentUnixTime + ") : " + SteamMatchmaking.AddFavoriteGame((AppId_t)480, 3494815209, 27015, 27015, Constants.k_unFavoriteFlagFavorite, CurrentUnixTime));
        }

        //if (GUILayout.Button("RemoveFavoriteGame((AppId_t)480, 3494815209, 27015, 27015, Constants.k_unFavoriteFlagFavorite)"))
        {
            Console.WriteLine("SteamMatchmaking.RemoveFavoriteGame(" + (AppId_t)480 + ", 3494815209, 27015, 27015, Constants.k_unFavoriteFlagFavorite) : " + SteamMatchmaking.RemoveFavoriteGame((AppId_t)480, 3494815209, 27015, 27015, Constants.k_unFavoriteFlagFavorite));
        }

        //if (GUILayout.Button("RequestLobbyList()"))
        {
            SteamAPICall_t handle = SteamMatchmaking.RequestLobbyList();
            OnLobbyMatchListCallResult.Set(handle);
            Console.WriteLine("SteamMatchmaking.RequestLobbyList() : " + handle);
        }

        //if (GUILayout.Button("AddRequestLobbyListStringFilter(\"SomeStringKey\", \"SomeValue\", ELobbyComparison.k_ELobbyComparisonNotEqual)"))
        {
            SteamMatchmaking.AddRequestLobbyListStringFilter("SomeStringKey", "SomeValue", ELobbyComparison.k_ELobbyComparisonNotEqual);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListStringFilter(\"SomeStringKey\", \"SomeValue\", ELobbyComparison.k_ELobbyComparisonNotEqual)");
        }

        //if (GUILayout.Button("AddRequestLobbyListNumericalFilter(\"SomeIntKey\", 0, ELobbyComparison.k_ELobbyComparisonNotEqual)"))
        {
            SteamMatchmaking.AddRequestLobbyListNumericalFilter("SomeIntKey", 0, ELobbyComparison.k_ELobbyComparisonNotEqual);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListNumericalFilter(\"SomeIntKey\", 0, ELobbyComparison.k_ELobbyComparisonNotEqual)");
        }

        //if (GUILayout.Button("AddRequestLobbyListNearValueFilter(\"SomeIntKey\", 0)"))
        {
            SteamMatchmaking.AddRequestLobbyListNearValueFilter("SomeIntKey", 0);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListNearValueFilter(\"SomeIntKey\", 0)");
        }

        //if (GUILayout.Button("AddRequestLobbyListFilterSlotsAvailable(3)"))
        {
            SteamMatchmaking.AddRequestLobbyListFilterSlotsAvailable(3);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListFilterSlotsAvailable(3)");
        }

        //if (GUILayout.Button("AddRequestLobbyListDistanceFilter(ELobbyDistanceFilter.k_ELobbyDistanceFilterWorldwide)"))
        {
            SteamMatchmaking.AddRequestLobbyListDistanceFilter(ELobbyDistanceFilter.k_ELobbyDistanceFilterWorldwide);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListDistanceFilter(ELobbyDistanceFilter.k_ELobbyDistanceFilterWorldwide)");
        }

        //if (GUILayout.Button("AddRequestLobbyListResultCountFilter(1)"))
        {
            SteamMatchmaking.AddRequestLobbyListResultCountFilter(1);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListResultCountFilter(1)");
        }

        //if (GUILayout.Button("AddRequestLobbyListCompatibleMembersFilter((CSteamID)0)"))
        {
            SteamMatchmaking.AddRequestLobbyListCompatibleMembersFilter((CSteamID)0);
            Console.WriteLine("SteamMatchmaking.AddRequestLobbyListCompatibleMembersFilter((CSteamID)0)");
        }

        //if (GUILayout.Button("GetLobbyByIndex(0)"))
        {
            m_Lobby = SteamMatchmaking.GetLobbyByIndex(0);
            Console.WriteLine("SteamMatchmaking.SteamMatchmaking.GetLobbyByIndex(0) : " + m_Lobby);
        }

        //if (GUILayout.Button("CreateLobby(ELobbyType.k_ELobbyTypePublic, 1)"))
        {
            SteamAPICall_t handle = SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 1);
            OnLobbyCreatedCallResult.Set(handle);
            Console.WriteLine("SteamMatchmaking.CreateLobby(ELobbyType.k_ELobbyTypePublic, 1) : " + handle);
        }

        //if (GUILayout.Button("JoinLobby(m_Lobby)"))
        {
            SteamAPICall_t handle = SteamMatchmaking.JoinLobby(m_Lobby);
            OnLobbyEnterCallResult.Set(handle);
            Console.WriteLine("SteamMatchmaking.JoinLobby(" + m_Lobby + ") : " + handle);
        }

        //if (GUILayout.Button("LeaveLobby(m_Lobby)"))
        {
            SteamMatchmaking.LeaveLobby(m_Lobby);
            m_Lobby = CSteamID.Nil;
            Console.WriteLine("SteamMatchmaking.LeaveLobby(" + m_Lobby + ")");
        }

        //if (GUILayout.Button("InviteUserToLobby(m_Lobby, SteamUser.GetSteamID())"))
        {
            Console.WriteLine("SteamMatchmaking.InviteUserToLobby(" + m_Lobby + ", SteamUser.GetSteamID()) : " + SteamMatchmaking.InviteUserToLobby(m_Lobby, SteamUser.GetSteamID()));
        }

        Console.WriteLine("GetNumLobbyMembers(m_Lobby) : " + SteamMatchmaking.GetNumLobbyMembers(m_Lobby));

        Console.WriteLine("GetLobbyMemberByIndex(m_Lobby, 0) : " + SteamMatchmaking.GetLobbyMemberByIndex(m_Lobby, 0));

        Console.WriteLine("SteamMatchmaking.GetLobbyData(m_Lobby, \"name\") : " + SteamMatchmaking.GetLobbyData(m_Lobby, "name"));

        //if (GUILayout.Button("SetLobbyData(m_Lobby, \"name\", \"Test Lobby!\")"))
        {
            Console.WriteLine("SteamMatchmaking.SetLobbyData(" + m_Lobby + ", \"name\", \"Test Lobby!\") : " + SteamMatchmaking.SetLobbyData(m_Lobby, "name", "Test Lobby!"));
        }

        Console.WriteLine("GetLobbyDataCount(m_Lobby) : " + SteamMatchmaking.GetLobbyDataCount(m_Lobby));

        {
            string Key;
            string Value;
            bool   ret = SteamMatchmaking.GetLobbyDataByIndex(m_Lobby, 0, out Key, 255, out Value, 255);
            Console.WriteLine("SteamMatchmaking.GetLobbyDataByIndex(m_Lobby, 0, out Key, 255, out Value, 255) : " + ret + " -- " + Key + " -- " + Value);
        }

        //if (GUILayout.Button("DeleteLobbyData(m_Lobby, \"name\")"))
        {
            Console.WriteLine("SteamMatchmaking.DeleteLobbyData(" + m_Lobby + ", \"name\") : " + SteamMatchmaking.DeleteLobbyData(m_Lobby, "name"));
        }

        {
            Console.WriteLine("SteamMatchmaking.GetLobbyMemberData(m_Lobby, SteamUser.GetSteamID(), \"test\") : " + SteamMatchmaking.GetLobbyMemberData(m_Lobby, SteamUser.GetSteamID(), "test"));
        }

        //if (GUILayout.Button("SetLobbyMemberData(m_Lobby, \"test\", \"This is a test Key!\")"))
        {
            SteamMatchmaking.SetLobbyMemberData(m_Lobby, "test", "This is a test Key!");
            Console.WriteLine("SteamMatchmaking.SetLobbyMemberData(" + m_Lobby + ", \"test\", \"This is a test Key!\")");
        }

        //if (GUILayout.Button("SendLobbyChatMsg(m_Lobby, MsgBody, MsgBody.Length)"))
        {
            byte[] MsgBody = System.Text.Encoding.UTF8.GetBytes("Test Message!");
            Console.WriteLine("SteamMatchmaking.SendLobbyChatMsg(" + m_Lobby + ", MsgBody, MsgBody.Length) : " + SteamMatchmaking.SendLobbyChatMsg(m_Lobby, MsgBody, MsgBody.Length));
        }

        //GetLobbyChatEntry(CSteamID steamIDLobby, int iChatID, out CSteamID pSteamIDUser, byte[] pvData, int cubData, out EChatEntryType peChatEntryType); // Only called from within OnLobbyChatMsg!

        //if (GUILayout.Button("RequestLobbyData(m_Lobby)"))
        {
            Console.WriteLine("SteamMatchmaking.RequestLobbyData(" + m_Lobby + ") : " + SteamMatchmaking.RequestLobbyData(m_Lobby));
        }

        //if (GUILayout.Button("SetLobbyGameServer(m_Lobby, 2130706433, 1337, CSteamID.NonSteamGS)"))
        {
            SteamMatchmaking.SetLobbyGameServer(m_Lobby, 2130706433, 1337, CSteamID.NonSteamGS); //127.0.0.1
            Console.WriteLine("SteamMatchmaking.SetLobbyGameServer(" + m_Lobby + ", 2130706433, 1337, CSteamID.NonSteamGS)");
        }

        {
            uint     GameServerIP;
            ushort   GameServerPort;
            CSteamID SteamIDGameServer;
            bool     ret = SteamMatchmaking.GetLobbyGameServer(m_Lobby, out GameServerIP, out GameServerPort, out SteamIDGameServer);
            Console.WriteLine("GetLobbyGameServer(m_Lobby, out GameServerIP, out GameServerPort, out SteamIDGameServer) : " + ret + " -- " + GameServerIP + " -- " + GameServerPort + " -- " + SteamIDGameServer);
        }

        //if (GUILayout.Button("SetLobbyMemberLimit(m_Lobby, 6)"))
        {
            Console.WriteLine("SteamMatchmaking.SteamMatchmaking.SetLobbyMemberLimit(" + m_Lobby + ", 6) : " + SteamMatchmaking.SetLobbyMemberLimit(m_Lobby, 6));
        }

        Console.WriteLine("GetLobbyMemberLimit(m_Lobby) : " + SteamMatchmaking.GetLobbyMemberLimit(m_Lobby));

        //if (GUILayout.Button("SetLobbyType(m_Lobby, ELobbyType.k_ELobbyTypePublic))"))
        {
            Console.WriteLine("SteamMatchmaking.SetLobbyType(" + m_Lobby + ", ELobbyType.k_ELobbyTypePublic)) : " + SteamMatchmaking.SetLobbyType(m_Lobby, ELobbyType.k_ELobbyTypePublic));
        }

        //if (GUILayout.Button("SetLobbyJoinable(m_Lobby, true)"))
        {
            Console.WriteLine("SteamMatchmaking.SetLobbyJoinable(" + m_Lobby + ", true) : " + SteamMatchmaking.SetLobbyJoinable(m_Lobby, true));
        }

        //if (GUILayout.Button("GetLobbyOwner(m_Lobby)"))
        {
            Console.WriteLine("SteamMatchmaking.GetLobbyOwner(" + m_Lobby + ") : " + SteamMatchmaking.GetLobbyOwner(m_Lobby));
        }

        //if (GUILayout.Button("SetLobbyOwner(m_Lobby, SteamUser.GetSteamID())"))
        {
            Console.WriteLine("SteamMatchmaking.SteamMatchmaking.SetLobbyOwner(" + m_Lobby + ", SteamUser.GetSteamID()) : " + SteamMatchmaking.SetLobbyOwner(m_Lobby, SteamUser.GetSteamID()));
        }

        //if (GUILayout.Button("SetLinkedLobby(m_Lobby, m_Lobby)"))
        {
            Console.WriteLine("SteamMatchmaking.SteamMatchmaking.SetLinkedLobby(" + m_Lobby + ", " + m_Lobby + ") : " + SteamMatchmaking.SetLinkedLobby(m_Lobby, m_Lobby));
        }
    }
示例#16
0
 public void RequestData()
 {
     SteamMatchmaking.RequestLobbyData(this.LobbyId);
 }