/// <summary>
        /// Add the user to the friendslist
        /// Invite the user to our group and the group passed by the admin
        /// Allowed string passed by admin: group url, groupID32 and groupID64, groupID64 is prefered because of error measures
        /// If a url is passed, so get the groupID64 from the grouppage
        /// groupID32 will be converted into a groupID64
        /// Welcome the user to the service and tell him we invited him to our Group
        /// </summary>
        /// <param name="_steamFriends"></param>
        /// <param name="_friendSteamID"></param>
        /// <param name="_groupID"></param>
        /// <param name="_steamUserWebAPI"></param>
        public async Task AcceptFriendRequestAndInviteToGroup(SteamFriends _steamFriends, SteamID _friendSteamID, SteamUserWebAPI _steamUserWebAPI, string _groupID = "")
        {
            _steamFriends.AddFriend(_friendSteamID);

            for (int i = 0; i < _steamFriends.GetClanCount(); i++)
            {
                SteamID groupID = _steamFriends.GetClanByIndex(i);
                if (groupID.ConvertToUInt64().Equals(103582791458407475) && _steamFriends.GetClanName(groupID).ToUpper().Contains("XETAS"))
                {
                    await _steamUserWebAPI.InviteToGroup(groupID.ToString(), _friendSteamID.ConvertToUInt64().ToString()).ConfigureAwait(false);
                }

                if (!string.IsNullOrEmpty(_groupID))
                {
                    string groupID64;
                    if (_groupID.Contains("steamcommunity") && _groupID.Contains("groups"))
                    {
                        groupID64 = await _steamUserWebAPI.GetGroupIDFromGroupAdress(_groupID).ConfigureAwait(false);
                    }
                    else
                    {
                        groupID64 = GetGroupID64String(_groupID);
                    }

                    await _steamUserWebAPI.InviteToGroup(groupID64, _friendSteamID.ConvertToUInt64().ToString()).ConfigureAwait(false);
                }
            }

            _steamFriends.SendChatMessage(_friendSteamID, EChatEntryType.ChatMsg, "Hello and welcome to my Service!" +
                                          "\nI've invited you to my group, where you can check the other bots or get to learn and trade with other steamusers." +
                                          "\nYou can type !c or !commands to see all available commands.");
        }
 public bool checkGroup(CSteamID steamID)
 {
     for (int i = 0; i < SteamFriends.GetClanCount(); i++)
     {
         if (SteamFriends.GetClanByIndex(i) == steamID)
         {
             return(true);
         }
     }
     return(false);
 }
    public void OnEnable()
    {
        if (SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate) == 0)
        {
            Debug.LogError("You must have atleast one friend to use the SteamFriends test!");
            enabled = false;
            return;
        }

        if (SteamFriends.GetClanCount() == 0)
        {
            Debug.LogError("You must have atleast one clan to use the SteamFriends test!");
            enabled = false;
            return;
        }

        m_PersonaStateChange = Callback <PersonaStateChange_t> .Create(OnPersonaStateChange);

        m_GameOverlayActivated = Callback <GameOverlayActivated_t> .Create(OnGameOverlayActivated);

        m_GameServerChangeRequested = Callback <GameServerChangeRequested_t> .Create(OnGameServerChangeRequested);

        m_GameLobbyJoinRequested = Callback <GameLobbyJoinRequested_t> .Create(OnGameLobbyJoinRequested);

        m_AvatarImageLoaded = Callback <AvatarImageLoaded_t> .Create(OnAvatarImageLoaded);

        m_FriendRichPresenceUpdate = Callback <FriendRichPresenceUpdate_t> .Create(OnFriendRichPresenceUpdate);

        m_GameRichPresenceJoinRequested = Callback <GameRichPresenceJoinRequested_t> .Create(OnGameRichPresenceJoinRequested);

        m_GameConnectedClanChatMsg = Callback <GameConnectedClanChatMsg_t> .Create(OnGameConnectedClanChatMsg);

        m_GameConnectedChatJoin = Callback <GameConnectedChatJoin_t> .Create(OnGameConnectedChatJoin);

        m_GameConnectedChatLeave = Callback <GameConnectedChatLeave_t> .Create(OnGameConnectedChatLeave);

        m_GameConnectedFriendChatMsg = Callback <GameConnectedFriendChatMsg_t> .Create(OnGameConnectedFriendChatMsg);

        m_UnreadChatMessagesChanged = Callback <UnreadChatMessagesChanged_t> .Create(OnUnreadChatMessagesChanged);

        OnClanOfficerListResponseCallResult = CallResult <ClanOfficerListResponse_t> .Create(OnClanOfficerListResponse);

        OnDownloadClanActivityCountsResultCallResult = CallResult <DownloadClanActivityCountsResult_t> .Create(OnDownloadClanActivityCountsResult);

        OnJoinClanChatRoomCompletionResultCallResult = CallResult <JoinClanChatRoomCompletionResult_t> .Create(OnJoinClanChatRoomCompletionResult);

        OnFriendsGetFollowerCountCallResult = CallResult <FriendsGetFollowerCount_t> .Create(OnFriendsGetFollowerCount);

        OnFriendsIsFollowingCallResult = CallResult <FriendsIsFollowing_t> .Create(OnFriendsIsFollowing);

        OnFriendsEnumerateFollowingListCallResult = CallResult <FriendsEnumerateFollowingList_t> .Create(OnFriendsEnumerateFollowingList);

        OnSetPersonaNameResponseCallResult = CallResult <SetPersonaNameResponse_t> .Create(OnSetPersonaNameResponse);
    }
 public SteamGroup[] getGroups()
 {
     SteamGroup[] array = new SteamGroup[SteamFriends.GetClanCount()];
     for (int i = 0; i < array.Length; i++)
     {
         CSteamID   clanByIndex = SteamFriends.GetClanByIndex(i);
         SteamGroup steamGroup  = this.getCachedGroup(clanByIndex);
         if (steamGroup == null)
         {
             string    clanName = SteamFriends.GetClanName(clanByIndex);
             Texture2D icon     = this.getIcon(clanByIndex);
             steamGroup = new SteamGroup(clanByIndex, clanName, icon);
             this.cachedGroups.Add(clanByIndex, steamGroup);
         }
         array[i] = steamGroup;
     }
     return(array);
 }
Exemple #5
0
        /// <summary>
        /// We do not want to send unnecessary webrequests
        /// So we do want to check if we are already a member of this group
        /// Therefore we want to loop trough all of our groups and check the groupID
        /// If we are already a member just leave the function
        /// If we are not a member join the group
        /// </summary>
        /// <param name="_steamFriends"></param>
        /// <param name="_groupID"></param>
        public async Task JoinGroupIfNotJoinedAlready(SteamFriends _steamFriends, ulong _groupID)
        {
            bool alreadyJoined = false;

            for (int i = 0; i < _steamFriends.GetClanCount(); i++)
            {
                SteamID groupID = _steamFriends.GetClanByIndex(i);
                if (groupID.ConvertToUInt64().Equals(_groupID))
                {
                    alreadyJoined = true;
                    break;
                }
            }

            if (!alreadyJoined)
            {
                await JoinGroup(_groupID.ToString()).ConfigureAwait(false);
            }
        }
Exemple #6
0
        public static void UserClanIDS()
        {
            for (var i = 0; i < steamFriends.GetClanCount(); i++)
            {
                SteamID steamIDClan = steamFriends.GetClanByIndex(i);
                if (!ClanDictionary.ContainsKey(steamIDClan))
                {
                    ClanDictionary.Add(steamIDClan, steamFriends.GetClanName(steamIDClan));
                }
            }

            if (ClanDictionary.ContainsKey(103582791464385054))
            {
                isInMercuryGroup = true;
            }
            else
            {
                isInMercuryGroup = false;
                Notification.NotifHelper.MessageBox.Show("Info", "Join Mercury group on steam! \n Link on INFORMATION Tab");
            }
        }
Exemple #7
0
        private void chatObjDropDownEvent(object sender, EventArgs e)
        {
            SteamFriends         steamFriend = this.core.Steam.SteamFriends;
            BindingList <string> chatObjSrc  = new BindingList <string>();

            this.userList.Clear();
            this.userList.Add(null);
            chatObjSrc.Add("######## Groups #######");
            for (int i = 0; i < steamFriend.GetClanCount(); i++)
            {
                this.userList.Add(steamFriend.GetClanByIndex(i));
                chatObjSrc.Add(steamFriend.GetClanName(steamFriend.GetClanByIndex(i)));
            }
            this.userList.Add(null);
            chatObjSrc.Add("####### online friends #######");
            for (int i = 0; i < this.core.Steam.SteamFriends.GetFriendCount(); i++)
            {
                if (this.core.Steam.SteamFriends.GetFriendPersonaState(steamFriend.GetFriendByIndex(i)) != EPersonaState.Offline)
                {
                    this.userList.Add(steamFriend.GetFriendByIndex(i));
                    chatObjSrc.Add(steamFriend.GetFriendPersonaName(this.core.Steam.SteamFriends.GetFriendByIndex(i)));
                }
            }
            if (this.showOfflineFriendCheck.Checked)
            {
                this.userList.Add(null);
                chatObjSrc.Add("####### offline friends #######");
                for (int i = 0; i < this.core.Steam.SteamFriends.GetFriendCount(); i++)
                {
                    if (this.core.Steam.SteamFriends.GetFriendPersonaState(steamFriend.GetFriendByIndex(i)) == EPersonaState.Offline)
                    {
                        this.userList.Add(steamFriend.GetFriendByIndex(i));
                        chatObjSrc.Add(steamFriend.GetFriendPersonaName(this.core.Steam.SteamFriends.GetFriendByIndex(i)));
                    }
                }
            }
            this.SelectChatObjCombo.DataSource = chatObjSrc;
        }
Exemple #8
0
    public void RenderOnGUI()
    {
        GUILayout.BeginArea(new Rect(Screen.width - 200, 0, 200, Screen.height));
        GUILayout.Label("Variables:");
        GUILayout.Label("m_Friend: " + m_Friend);
        GUILayout.Label("m_Clan: " + m_Clan);
        GUILayout.Label("m_CoPlayFriend: " + m_CoPlayFriend);
        GUILayout.Label("m_SmallAvatar:");
        GUILayout.Label(m_SmallAvatar);
        GUILayout.Label("m_MediumAvatar:");
        GUILayout.Label(m_MediumAvatar);
        GUILayout.Label("m_LargeAvatar:");
        GUILayout.Label(m_LargeAvatar);
        GUILayout.EndArea();

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

        GUILayout.Label("GetPersonaName() : " + SteamFriends.GetPersonaName());

        if (GUILayout.Button("SetPersonaName(SteamFriends.GetPersonaName())"))
        {
            SteamAPICall_t handle = SteamFriends.SetPersonaName(SteamFriends.GetPersonaName());
            OnSetPersonaNameResponseCallResult.Set(handle);
            print("SteamFriends.SetPersonaName(" + SteamFriends.GetPersonaName() + ") : " + handle);
        }

        GUILayout.Label("GetPersonaState() : " + SteamFriends.GetPersonaState());

        GUILayout.Label("GetFriendCount(EFriendFlags.k_EFriendFlagImmediate) : " + SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate));

        {
            m_Friend = SteamFriends.GetFriendByIndex(0, EFriendFlags.k_EFriendFlagImmediate);
            GUILayout.Label("GetFriendByIndex(0, EFriendFlags.k_EFriendFlagImmediate) : " + m_Friend);
        }

        GUILayout.Label("GetFriendRelationship(m_Friend) : " + SteamFriends.GetFriendRelationship(m_Friend));

        GUILayout.Label("GetFriendPersonaState(m_Friend) : " + SteamFriends.GetFriendPersonaState(m_Friend));

        GUILayout.Label("GetFriendPersonaName(m_Friend) : " + SteamFriends.GetFriendPersonaName(m_Friend));

        {
            var  fgi = new FriendGameInfo_t();
            bool ret = SteamFriends.GetFriendGamePlayed(m_Friend, out fgi);
            GUILayout.Label("GetFriendGamePlayed(m_Friend, out fgi) : " + ret + " -- " + fgi.m_gameID + " -- " + fgi.m_unGameIP + " -- " + fgi.m_usGamePort + " -- " + fgi.m_usQueryPort + " -- " + fgi.m_steamIDLobby);
        }

        GUILayout.Label("GetFriendPersonaNameHistory(m_Friend, 1) : " + SteamFriends.GetFriendPersonaNameHistory(m_Friend, 1));

        GUILayout.Label("GetFriendSteamLevel(m_Friend) : " + SteamFriends.GetFriendSteamLevel(m_Friend));

        GUILayout.Label("GetPlayerNickname(m_Friend) : " + SteamFriends.GetPlayerNickname(m_Friend));

        {
            int FriendsGroupCount = SteamFriends.GetFriendsGroupCount();
            GUILayout.Label("GetFriendsGroupCount() : " + FriendsGroupCount);

            if (FriendsGroupCount > 0)
            {
                FriendsGroupID_t FriendsGroupID = SteamFriends.GetFriendsGroupIDByIndex(0);
                GUILayout.Label("SteamFriends.GetFriendsGroupIDByIndex(0) : " + FriendsGroupID);

                GUILayout.Label("GetFriendsGroupName(FriendsGroupID) : " + SteamFriends.GetFriendsGroupName(FriendsGroupID));

                int FriendsGroupMembersCount = SteamFriends.GetFriendsGroupMembersCount(FriendsGroupID);
                GUILayout.Label("GetFriendsGroupMembersCount(FriendsGroupID) : " + FriendsGroupMembersCount);

                if (FriendsGroupMembersCount > 0)
                {
                    CSteamID[] FriendsGroupMembersList = new CSteamID[FriendsGroupMembersCount];
                    SteamFriends.GetFriendsGroupMembersList(FriendsGroupID, FriendsGroupMembersList, FriendsGroupMembersCount);
                    GUILayout.Label("GetFriendsGroupMembersList(FriendsGroupID, FriendsGroupMembersList, FriendsGroupMembersCount) : " + FriendsGroupMembersList[0]);
                }
            }
        }

        GUILayout.Label("HasFriend(m_Friend, EFriendFlags.k_EFriendFlagImmediate) : " + SteamFriends.HasFriend(m_Friend, EFriendFlags.k_EFriendFlagImmediate));

        GUILayout.Label("GetClanCount() : " + SteamFriends.GetClanCount());

        m_Clan = SteamFriends.GetClanByIndex(0);
        GUILayout.Label("GetClanByIndex(0) : " + m_Clan);

        GUILayout.Label("GetClanName(m_Clan) : " + SteamFriends.GetClanName(m_Clan));

        GUILayout.Label("GetClanTag(m_Clan) : " + SteamFriends.GetClanTag(m_Clan));

        {
            int  Online;
            int  InGame;
            int  Chatting;
            bool ret = SteamFriends.GetClanActivityCounts(m_Clan, out Online, out InGame, out Chatting);
            GUILayout.Label("GetClanActivityCounts(m_Clan, out Online, out InGame, out Chatting) : " + ret + " -- " + Online + " -- " + InGame + " -- " + Chatting);
        }

        if (GUILayout.Button("DownloadClanActivityCounts(Clans, Clans.Length)"))
        {
            CSteamID[]     Clans  = { m_Clan, TestConstants.Instance.k_SteamId_Group_SteamUniverse };
            SteamAPICall_t handle = SteamFriends.DownloadClanActivityCounts(Clans, Clans.Length);
            OnDownloadClanActivityCountsResultCallResult.Set(handle);             // This call never seems to produce the CallResult.
            print("SteamFriends.DownloadClanActivityCounts(" + Clans + ", " + Clans.Length + ") : " + handle);
        }

        {
            int FriendCount = SteamFriends.GetFriendCountFromSource(m_Clan);
            GUILayout.Label("GetFriendCountFromSource(m_Clan) : " + FriendCount);

            if (FriendCount > 0)
            {
                GUILayout.Label("GetFriendFromSourceByIndex(m_Clan, 0) : " + SteamFriends.GetFriendFromSourceByIndex(m_Clan, 0));
            }
        }

        GUILayout.Label("IsUserInSource(m_Friend, m_Clan) : " + SteamFriends.IsUserInSource(m_Friend, m_Clan));

        if (GUILayout.Button("SetInGameVoiceSpeaking(SteamUser.GetSteamID(), false)"))
        {
            SteamFriends.SetInGameVoiceSpeaking(SteamUser.GetSteamID(), false);
            print("SteamFriends.SetInGameVoiceSpeaking(" + SteamUser.GetSteamID() + ", " + false + ")");
        }

        if (GUILayout.Button("ActivateGameOverlay(\"Friends\")"))
        {
            SteamFriends.ActivateGameOverlay("Friends");
            print("SteamFriends.ActivateGameOverlay(" + "\"Friends\"" + ")");
        }

        if (GUILayout.Button("ActivateGameOverlayToUser(\"friendadd\", TestConstants.Instance.k_SteamId_rlabrecque)"))
        {
            SteamFriends.ActivateGameOverlayToUser("friendadd", TestConstants.Instance.k_SteamId_rlabrecque);
            print("SteamFriends.ActivateGameOverlayToUser(" + "\"friendadd\"" + ", " + TestConstants.Instance.k_SteamId_rlabrecque + ")");
        }

        if (GUILayout.Button("ActivateGameOverlayToWebPage(\"http://steamworks.github.io\")"))
        {
            SteamFriends.ActivateGameOverlayToWebPage("http://steamworks.github.io");
            print("SteamFriends.ActivateGameOverlayToWebPage(" + "\"http://steamworks.github.io\"" + ")");
        }

        if (GUILayout.Button("ActivateGameOverlayToStore(TestConstants.Instance.k_AppId_TeamFortress2, EOverlayToStoreFlag.k_EOverlayToStoreFlag_None)"))
        {
            SteamFriends.ActivateGameOverlayToStore(TestConstants.Instance.k_AppId_TeamFortress2, EOverlayToStoreFlag.k_EOverlayToStoreFlag_None);
            print("SteamFriends.ActivateGameOverlayToStore(" + TestConstants.Instance.k_AppId_TeamFortress2 + ", " + EOverlayToStoreFlag.k_EOverlayToStoreFlag_None + ")");
        }

        if (GUILayout.Button("SetPlayedWith(TestConstants.Instance.k_SteamId_rlabrecque)"))
        {
            SteamFriends.SetPlayedWith(TestConstants.Instance.k_SteamId_rlabrecque);
            print("SteamFriends.SetPlayedWith(" + TestConstants.Instance.k_SteamId_rlabrecque + ")");
        }

        if (GUILayout.Button("ActivateGameOverlayInviteDialog(TestConstants.Instance.k_SteamId_rlabrecque)"))
        {
            SteamFriends.ActivateGameOverlayInviteDialog(TestConstants.Instance.k_SteamId_rlabrecque);
            print("SteamFriends.ActivateGameOverlayInviteDialog(" + TestConstants.Instance.k_SteamId_rlabrecque + ")");
        }

        if (GUILayout.Button("GetSmallFriendAvatar(m_Friend)"))
        {
            int ret = SteamFriends.GetSmallFriendAvatar(m_Friend);
            print("SteamFriends.GetSmallFriendAvatar(" + m_Friend + ") : " + ret);
            m_SmallAvatar = SteamUtilsTest.GetSteamImageAsTexture2D(ret);
        }

        if (GUILayout.Button("GetMediumFriendAvatar(m_Friend)"))
        {
            int ret = SteamFriends.GetMediumFriendAvatar(m_Friend);
            print("SteamFriends.GetMediumFriendAvatar(" + m_Friend + ") : " + ret);
            m_MediumAvatar = SteamUtilsTest.GetSteamImageAsTexture2D(ret);
        }

        if (GUILayout.Button("GetLargeFriendAvatar(m_Friend)"))
        {
            int ret = SteamFriends.GetLargeFriendAvatar(m_Friend);
            print("SteamFriends.GetLargeFriendAvatar(" + m_Friend + ") : " + ret);
            m_LargeAvatar = SteamUtilsTest.GetSteamImageAsTexture2D(ret);
        }

        if (GUILayout.Button("RequestUserInformation(m_Friend, false)"))
        {
            bool ret = SteamFriends.RequestUserInformation(m_Friend, false);
            print("SteamFriends.RequestUserInformation(" + m_Friend + ", " + false + ") : " + ret);
        }

        if (GUILayout.Button("RequestClanOfficerList(m_Clan)"))
        {
            SteamAPICall_t handle = SteamFriends.RequestClanOfficerList(m_Clan);
            OnClanOfficerListResponseCallResult.Set(handle);
            print("SteamFriends.RequestClanOfficerList(" + m_Clan + ") : " + handle);
        }

        GUILayout.Label("GetClanOwner(m_Clan) : " + SteamFriends.GetClanOwner(m_Clan));

        GUILayout.Label("GetClanOfficerCount(m_Clan) : " + SteamFriends.GetClanOfficerCount(m_Clan));

        GUILayout.Label("GetClanOfficerByIndex(m_Clan, 0) : " + SteamFriends.GetClanOfficerByIndex(m_Clan, 0));

        GUILayout.Label("GetUserRestrictions() : " + SteamFriends.GetUserRestrictions());

        if (GUILayout.Button("SetRichPresence(\"status\", \"Testing 1.. 2.. 3..\")"))
        {
            bool ret = SteamFriends.SetRichPresence("status", "Testing 1.. 2.. 3..");
            print("SteamFriends.SetRichPresence(" + "\"status\"" + ", " + "\"Testing 1.. 2.. 3..\"" + ") : " + ret);
        }

        if (GUILayout.Button("ClearRichPresence()"))
        {
            SteamFriends.ClearRichPresence();
            print("SteamFriends.ClearRichPresence()");
        }

        GUILayout.Label("GetFriendRichPresence(SteamUser.GetSteamID(), \"status\") : " + SteamFriends.GetFriendRichPresence(SteamUser.GetSteamID(), "status"));

        GUILayout.Label("GetFriendRichPresenceKeyCount(SteamUser.GetSteamID()) : " + SteamFriends.GetFriendRichPresenceKeyCount(SteamUser.GetSteamID()));

        GUILayout.Label("GetFriendRichPresenceKeyByIndex(SteamUser.GetSteamID(), 0) : " + SteamFriends.GetFriendRichPresenceKeyByIndex(SteamUser.GetSteamID(), 0));

        if (GUILayout.Button("RequestFriendRichPresence(m_Friend)"))
        {
            SteamFriends.RequestFriendRichPresence(m_Friend);
            print("SteamFriends.RequestFriendRichPresence(" + m_Friend + ")");
        }

        if (GUILayout.Button("InviteUserToGame(SteamUser.GetSteamID(), \"testing\")"))
        {
            bool ret = SteamFriends.InviteUserToGame(SteamUser.GetSteamID(), "testing");
            print("SteamFriends.InviteUserToGame(" + SteamUser.GetSteamID() + ", " + "\"testing\"" + ") : " + ret);
        }

        GUILayout.Label("GetCoplayFriendCount() : " + SteamFriends.GetCoplayFriendCount());

        if (GUILayout.Button("GetCoplayFriend(0)"))
        {
            m_CoPlayFriend = SteamFriends.GetCoplayFriend(0);
            print("SteamFriends.GetCoplayFriend(" + 0 + ") : " + m_CoPlayFriend);
        }

        GUILayout.Label("GetFriendCoplayTime(m_CoPlayFriend) : " + SteamFriends.GetFriendCoplayTime(m_CoPlayFriend));

        GUILayout.Label("GetFriendCoplayGame(m_CoPlayFriend) : " + SteamFriends.GetFriendCoplayGame(m_CoPlayFriend));

        if (GUILayout.Button("JoinClanChatRoom(m_Clan)"))
        {
            SteamAPICall_t handle = SteamFriends.JoinClanChatRoom(m_Clan);
            OnJoinClanChatRoomCompletionResultCallResult.Set(handle);
            print("SteamFriends.JoinClanChatRoom(" + m_Clan + ") : " + handle);
        }

        if (GUILayout.Button("LeaveClanChatRoom(m_Clan)"))
        {
            bool ret = SteamFriends.LeaveClanChatRoom(m_Clan);
            print("SteamFriends.LeaveClanChatRoom(" + m_Clan + ") : " + ret);
        }

        GUILayout.Label("GetClanChatMemberCount(m_Clan) : " + SteamFriends.GetClanChatMemberCount(m_Clan));

        GUILayout.Label("GetChatMemberByIndex(m_Clan, 0) : " + SteamFriends.GetChatMemberByIndex(m_Clan, 0));

        if (GUILayout.Button("SendClanChatMessage(m_Clan, \"Test\")"))
        {
            bool ret = SteamFriends.SendClanChatMessage(m_Clan, "Test");
            print("SteamFriends.SendClanChatMessage(" + m_Clan + ", " + "\"Test\"" + ") : " + ret);
        }

        //GUILayout.Label("SteamFriends.GetClanChatMessage() : " + SteamFriends.GetClanChatMessage()); // N/A - Must be called from within the callback OnGameConnectedClanChatMsg

        GUILayout.Label("IsClanChatAdmin(m_Clan, m_Friend) : " + SteamFriends.IsClanChatAdmin(m_Clan, m_Friend));

        GUILayout.Label("IsClanChatWindowOpenInSteam(m_Clan) : " + SteamFriends.IsClanChatWindowOpenInSteam(m_Clan));

        if (GUILayout.Button("OpenClanChatWindowInSteam(m_Clan)"))
        {
            bool ret = SteamFriends.OpenClanChatWindowInSteam(m_Clan);
            print("SteamFriends.OpenClanChatWindowInSteam(" + m_Clan + ") : " + ret);
        }

        if (GUILayout.Button("CloseClanChatWindowInSteam(m_Clan)"))
        {
            bool ret = SteamFriends.CloseClanChatWindowInSteam(m_Clan);
            print("SteamFriends.CloseClanChatWindowInSteam(" + m_Clan + ") : " + ret);
        }

        if (GUILayout.Button("SetListenForFriendsMessages(true)"))
        {
            bool ret = SteamFriends.SetListenForFriendsMessages(true);
            print("SteamFriends.SetListenForFriendsMessages(" + true + ") : " + ret);
        }

        if (GUILayout.Button("ReplyToFriendMessage(SteamUser.GetSteamID(), \"Testing!\")"))
        {
            bool ret = SteamFriends.ReplyToFriendMessage(SteamUser.GetSteamID(), "Testing!");
            print("SteamFriends.ReplyToFriendMessage(" + SteamUser.GetSteamID() + ", " + "\"Testing!\"" + ") : " + ret);
        }

        //GUILayout.Label("SteamFriends.GetFriendMessage() : " + SteamFriends.GetFriendMessage()); // N/A - Must be called from within the callback OnGameConnectedFriendChatMsg

        if (GUILayout.Button("GetFollowerCount(SteamUser.GetSteamID())"))
        {
            SteamAPICall_t handle = SteamFriends.GetFollowerCount(SteamUser.GetSteamID());
            OnFriendsGetFollowerCountCallResult.Set(handle);
            print("SteamFriends.GetFollowerCount(" + SteamUser.GetSteamID() + ") : " + handle);
        }

        if (GUILayout.Button("IsFollowing(m_Friend)"))
        {
            SteamAPICall_t handle = SteamFriends.IsFollowing(m_Friend);
            OnFriendsIsFollowingCallResult.Set(handle);
            print("SteamFriends.IsFollowing(" + m_Friend + ") : " + handle);
        }

        if (GUILayout.Button("EnumerateFollowingList(0)"))
        {
            SteamAPICall_t handle = SteamFriends.EnumerateFollowingList(0);
            OnFriendsEnumerateFollowingListCallResult.Set(handle);
            print("SteamFriends.EnumerateFollowingList(" + 0 + ") : " + handle);
        }

        GUILayout.Label("IsClanPublic(m_Clan) : " + SteamFriends.IsClanPublic(m_Clan));

        GUILayout.Label("IsClanOfficialGameGroup(m_Clan) : " + SteamFriends.IsClanOfficialGameGroup(m_Clan));

        GUILayout.EndScrollView();
        GUILayout.EndVertical();
    }
Exemple #9
0
    private void RenderPageOne()
    {
        GUILayout.Label("SteamFriends.GetPersonaName() : " + SteamFriends.GetPersonaName());

        if (GUILayout.Button("SteamFriends.SetPersonaName(SteamFriends.GetPersonaName())"))
        {
            SteamAPICall_t handle = SteamFriends.SetPersonaName(SteamFriends.GetPersonaName());
            OnSetPersonaNameResponseCallResult.Set(handle);
            print("SteamFriends.SetPersonaName(" + SteamFriends.GetPersonaName() + ") : " + handle);
        }

        GUILayout.Label("SteamFriends.GetPersonaState() : " + SteamFriends.GetPersonaState());
        GUILayout.Label("SteamFriends.GetFriendCount(k_EFriendFlagImmediate) : " + SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate));
        if (SteamFriends.GetFriendCount(EFriendFlags.k_EFriendFlagImmediate) == 0)
        {
            Debug.LogError("You must have atleast one friend to use this Test");
            return;
        }

        m_Friend = SteamFriends.GetFriendByIndex(0, EFriendFlags.k_EFriendFlagImmediate);
        GUILayout.Label("SteamFriends.GetFriendByIndex(0, k_EFriendFlagImmediate) : " + m_Friend);
        GUILayout.Label("SteamFriends.GetFriendRelationship(m_Friend) : " + SteamFriends.GetFriendRelationship(m_Friend));
        GUILayout.Label("SteamFriends.GetFriendPersonaState(m_Friend) : " + SteamFriends.GetFriendPersonaState(m_Friend));
        GUILayout.Label("SteamFriends.GetFriendPersonaName(m_Friend) : " + SteamFriends.GetFriendPersonaName(m_Friend));

        {
            var  fgi = new FriendGameInfo_t();
            bool ret = SteamFriends.GetFriendGamePlayed(m_Friend, out fgi);
            GUILayout.Label("SteamFriends.GetFriendGamePlayed(m_Friend, out fgi) : " + ret + " -- " + fgi.m_gameID + " -- " + fgi.m_unGameIP + " -- " + fgi.m_usGamePort + " -- " + fgi.m_usQueryPort + " -- " + fgi.m_steamIDLobby);
        }


        GUILayout.Label("SteamFriends.GetFriendPersonaNameHistory(m_Friend, 1) : " + SteamFriends.GetFriendPersonaNameHistory(m_Friend, 1));
        GUILayout.Label("SteamFriends.GetFriendSteamLevel(m_Friend) : " + SteamFriends.GetFriendSteamLevel(m_Friend));
        GUILayout.Label("SteamFriends.GetPlayerNickname(m_Friend) : " + SteamFriends.GetPlayerNickname(m_Friend));

        {
            int FriendsGroupCount = SteamFriends.GetFriendsGroupCount();
            GUILayout.Label("SteamFriends.GetFriendsGroupCount() : " + FriendsGroupCount);

            if (FriendsGroupCount > 0)
            {
                FriendsGroupID_t FriendsGroupID = SteamFriends.GetFriendsGroupIDByIndex(0);
                GUILayout.Label("SteamFriends.GetFriendsGroupIDByIndex(0) : " + FriendsGroupID);
                GUILayout.Label("SteamFriends.GetFriendsGroupName(FriendsGroupID) : " + SteamFriends.GetFriendsGroupName(FriendsGroupID));

                int FriendsGroupMembersCount = SteamFriends.GetFriendsGroupMembersCount(FriendsGroupID);
                GUILayout.Label("SteamFriends.GetFriendsGroupMembersCount(FriendsGroupID) : " + FriendsGroupMembersCount);

                if (FriendsGroupMembersCount > 0)
                {
                    CSteamID[] FriendsGroupMembersList = new CSteamID[FriendsGroupMembersCount];
                    SteamFriends.GetFriendsGroupMembersList(FriendsGroupID, FriendsGroupMembersList, FriendsGroupMembersCount);
                    GUILayout.Label("SteamFriends.GetFriendsGroupMembersList(FriendsGroupID, FriendsGroupMembersList, FriendsGroupMembersCount) : " + FriendsGroupMembersList[0]);
                }
            }
        }

        GUILayout.Label("SteamFriends.HasFriend(m_Friend, k_EFriendFlagImmediate) : " + SteamFriends.HasFriend(m_Friend, EFriendFlags.k_EFriendFlagImmediate));

        GUILayout.Label("SteamFriends.GetClanCount() : " + SteamFriends.GetClanCount());
        if (SteamFriends.GetClanCount() == 0)
        {
            Debug.LogError("You must have atleast one clan to use this Test");
            return;
        }

        m_Clan = SteamFriends.GetClanByIndex(0);
        GUILayout.Label("SteamFriends.GetClanByIndex(0) : " + m_Clan);
        GUILayout.Label("SteamFriends.GetClanName(m_Clan) : " + SteamFriends.GetClanName(m_Clan));
        GUILayout.Label("SteamFriends.GetClanTag(m_Clan) : " + SteamFriends.GetClanTag(m_Clan));

        {
            int  Online;
            int  InGame;
            int  Chatting;
            bool ret = SteamFriends.GetClanActivityCounts(m_Clan, out Online, out InGame, out Chatting);
            GUILayout.Label("SteamFriends.GetClanActivityCounts(m_Clan, out Online, out InGame, out Chatting) : " + ret + " -- " + Online + " -- " + InGame + " -- " + Chatting);
        }

        if (GUILayout.Button("SteamFriends.DownloadClanActivityCounts(m_Clans, 2)"))
        {
            CSteamID[]     Clans  = { m_Clan, new CSteamID(103582791434672565) }; // m_Clan, Steam Universe
            SteamAPICall_t handle = SteamFriends.DownloadClanActivityCounts(Clans, 2);
            OnDownloadClanActivityCountsResultCallResult.Set(handle);             // This call never seems to produce a callback.
            print("SteamFriends.DownloadClanActivityCounts(" + Clans + ", 2) : " + handle);
        }

        {
            int FriendCount = SteamFriends.GetFriendCountFromSource(m_Clan);
            GUILayout.Label("SteamFriends.GetFriendCountFromSource(m_Clan) : " + FriendCount);

            if (FriendCount > 0)
            {
                GUILayout.Label("SteamFriends.GetFriendFromSourceByIndex(m_Clan, 0) : " + SteamFriends.GetFriendFromSourceByIndex(m_Clan, 0));
            }
        }

        GUILayout.Label("SteamFriends.IsUserInSource(m_Friend, m_Clan) : " + SteamFriends.IsUserInSource(m_Friend, m_Clan));

        if (GUILayout.Button("SteamFriends.SetInGameVoiceSpeaking(SteamUser.GetSteamID(), false)"))
        {
            SteamFriends.SetInGameVoiceSpeaking(SteamUser.GetSteamID(), false);
            print("SteamClient.SetInGameVoiceSpeaking(" + SteamUser.GetSteamID() + ", false);");
        }

        if (GUILayout.Button("SteamFriends.ActivateGameOverlay(\"Friends\")"))
        {
            SteamFriends.ActivateGameOverlay("Friends");
            print("SteamClient.ActivateGameOverlay(\"Friends\")");
        }

        if (GUILayout.Button("SteamFriends.ActivateGameOverlayToUser(\"friendadd\", 76561197991230424)"))
        {
            SteamFriends.ActivateGameOverlayToUser("friendadd", new CSteamID(76561197991230424));             // rlabrecque
            print("SteamClient.ActivateGameOverlay(\"friendadd\", 76561197991230424)");
        }

        if (GUILayout.Button("SteamFriends.ActivateGameOverlayToWebPage(\"http://google.com\")"))
        {
            SteamFriends.ActivateGameOverlayToWebPage("http://google.com");
            print("SteamClient.ActivateGameOverlay(\"http://google.com\")");
        }

        if (GUILayout.Button("SteamFriends.ActivateGameOverlayToStore(440, k_EOverlayToStoreFlag_None)"))
        {
            SteamFriends.ActivateGameOverlayToStore((AppId_t)440, EOverlayToStoreFlag.k_EOverlayToStoreFlag_None);             // 440 = TF2
            print("SteamClient.ActivateGameOverlay(440, k_EOverlayToStoreFlag_None)");
        }

        if (GUILayout.Button("SteamFriends.SetPlayedWith(76561197991230424)"))
        {
            SteamFriends.SetPlayedWith(new CSteamID(76561197991230424));             //rlabrecque
            print("SteamClient.SetPlayedWith(76561197991230424)");
        }

        if (GUILayout.Button("SteamFriends.ActivateGameOverlayInviteDialog(76561197991230424)"))
        {
            SteamFriends.ActivateGameOverlayInviteDialog(new CSteamID(76561197991230424));             //rlabrecque
            print("SteamClient.ActivateGameOverlayInviteDialog(76561197991230424)");
        }

        if (GUILayout.Button("SteamFriends.GetSmallFriendAvatar(m_Friend)"))
        {
            int FriendAvatar = SteamFriends.GetSmallFriendAvatar(m_Friend);
            print("SteamFriends.GetSmallFriendAvatar(" + m_Friend + ") - " + FriendAvatar);

            uint ImageWidth;
            uint ImageHeight;
            bool ret = SteamUtils.GetImageSize(FriendAvatar, out ImageWidth, out ImageHeight);

            if (ret && ImageWidth > 0 && ImageHeight > 0)
            {
                byte[] Image = new byte[ImageWidth * ImageHeight * 4];

                ret = SteamUtils.GetImageRGBA(FriendAvatar, Image, (int)(ImageWidth * ImageHeight * 4));

                m_SmallAvatar = new Texture2D((int)ImageWidth, (int)ImageHeight, TextureFormat.RGBA32, false, true);
                m_SmallAvatar.LoadRawTextureData(Image);                 // The image is upside down! "@ares_p: in Unity all texture data starts from "bottom" (OpenGL convention)"
                m_SmallAvatar.Apply();
            }
        }

        if (GUILayout.Button("SteamFriends.GetMediumFriendAvatar(m_Friend)"))
        {
            int FriendAvatar = SteamFriends.GetMediumFriendAvatar(m_Friend);
            print("SteamFriends.GetMediumFriendAvatar(" + m_Friend + ") - " + FriendAvatar);

            uint ImageWidth;
            uint ImageHeight;
            bool ret = SteamUtils.GetImageSize(FriendAvatar, out ImageWidth, out ImageHeight);

            if (ret && ImageWidth > 0 && ImageHeight > 0)
            {
                byte[] Image = new byte[ImageWidth * ImageHeight * 4];

                ret            = SteamUtils.GetImageRGBA(FriendAvatar, Image, (int)(ImageWidth * ImageHeight * 4));
                m_MediumAvatar = new Texture2D((int)ImageWidth, (int)ImageHeight, TextureFormat.RGBA32, false, true);
                m_MediumAvatar.LoadRawTextureData(Image);
                m_MediumAvatar.Apply();
            }
        }

        if (GUILayout.Button("SteamFriends.GetLargeFriendAvatar(m_Friend)"))
        {
            int FriendAvatar = SteamFriends.GetLargeFriendAvatar(m_Friend);
            print("SteamFriends.GetLargeFriendAvatar(" + m_Friend + ") - " + FriendAvatar);

            uint ImageWidth;
            uint ImageHeight;
            bool ret = SteamUtils.GetImageSize(FriendAvatar, out ImageWidth, out ImageHeight);

            if (ret && ImageWidth > 0 && ImageHeight > 0)
            {
                byte[] Image = new byte[ImageWidth * ImageHeight * 4];

                ret = SteamUtils.GetImageRGBA(FriendAvatar, Image, (int)(ImageWidth * ImageHeight * 4));
                if (ret)
                {
                    m_LargeAvatar = new Texture2D((int)ImageWidth, (int)ImageHeight, TextureFormat.RGBA32, false, true);
                    m_LargeAvatar.LoadRawTextureData(Image);
                    m_LargeAvatar.Apply();
                }
            }
        }
    }
Exemple #10
0
 public int GetClanCount() => steam_friends.GetClanCount();