steam游戏上架流程四：Steamworks SDK 的API 方法回调方式 ( Callback )

柔情只为你懂 2023-07-06 09:50 11阅读 0赞

参考:

steamworks.net 官方文档的说明 [http://steamworks.github.io/gettingstarted/][http_steamworks.github.io_gettingstarted]

steam游戏上架流程一：使用官方SDK上传游戏  [https://blog.csdn.net/qq\_42672770/article/details/104425473][https_blog.csdn.net_qq_42672770_article_details_104425473]

steam游戏上架流程二：steamworks.net  SDK API对接unity [https://blog.csdn.net/qq\_42672770/article/details/104444771][https_blog.csdn.net_qq_42672770_article_details_104444771]

steam游戏上架流程三： 游戏的发布配置与测试 [https://blog.csdn.net/qq\_42672770/article/details/104444894][https_blog.csdn.net_qq_42672770_article_details_104444894]

steam游戏上架流程四：Steamworks的API 方法回调方式  [https://blog.csdn.net/qq\_42672770/article/details/104361853][https_blog.csdn.net_qq_42672770_article_details_104361853]

Steamworks SDK主要使用 **回调方式 ( Callback ) **从服务器异步获取需要的数据，而且这个过程中并不需要暂停游戏进程。

其中有一个你肯定希望用到的回调是 `GameOverlayActivated_t， 没错！意思就是每次你的Steam的 Steam Overlay 打开或关闭时服务器都会发送给你的客户端一个callback，来控制游戏的暂停。`

要想使用这些回调，客户端（**委托方**）必须**先声明 一个回调（委托） protected Callback< > 作为客户端（委托方）的一个成员变量**。如：

**public** **class** SteamScript : MonoBehaviour \{  
   ** protected Callback< GameOverlayActivated\_t >**  m\_GameOverlayActivated;  
\}

然后通过调用 **Callback< >.Create() 创建一个具体的回调（委托）实例**。

public class SteamScript : MonoBehaviour \{

protected Callback<GameOverlayActivated\_t> m\_GameOverlayActivated;

private void **OnEnable()** \{  //通常把回调创建放在OnEnable方法内以确保Unity加载完成后重复创建回调

if (SteamManager.Initialized) \{  //在调用任何Steamworks方法前需要先判断steam是否初始化完成

m\_GameOverlayActivated = Callback<GameOverlayActivated\_t>**.Create**( **OnGameOverlayActivated **);

private void **OnGameOverlayActivated**(GameOverlayActivated\_t    pCallback) \{

if(pCallback.m\_bActive != 0) \{

Debug.Log("Steam Overlay has been activated");

else \{

Debug.Log("Steam Overlay has been closed");

public class SteamScript : MonoBehaviour \{  
    private CallResult<NumberOfCurrentPlayers\_t>  m\_NumberOfCurrentPlayers;  
   
    private void **OnEnable()** \{  
        if (SteamManager.Initialized) \{  
            m\_NumberOfCurrentPlayers = CallResult<NumberOfCurrentPlayers\_t>**.Create**(OnNumberOfCurrentPlayers);  
        \}  
    \}  
   
    private void OnNumberOfCurrentPlayers(NumberOfCurrentPlayers\_t pCallback, bool bIOFailure) \{  
        if (pCallback.m\_bSuccess != 1 || bIOFailure) \{  
            Debug.Log("There was an error retrieving the NumberOfCurrentPlayers.");  
        \}  
        else \{  
            Debug.Log("The number of players playing your game: " + pCallback.m\_cPlayers);  
        \}  
    \}  
\}

关于回调的结果，声明CallResult<T>接收。

public class SteamScript : MonoBehaviour \{  
    private CallResult<NumberOfCurrentPlayers\_t> m\_NumberOfCurrentPlayers;  
   
    private void **OnEnable()** \{  
        if (SteamManager.Initialized) \{  
            m\_NumberOfCurrentPlayers = CallResult<NumberOfCurrentPlayers\_t>**.Create**(OnNumberOfCurrentPlayers);  
        \}  
    \}  
   
    private void OnNumberOfCurrentPlayers(NumberOfCurrentPlayers\_t pCallback, bool bIOFailure) \{  
        if (pCallback.m\_bSuccess != 1 || bIOFailure) \{  
            Debug.Log("There was an error retrieving the NumberOfCurrentPlayers.");  
        \}  
        else \{  
            Debug.Log("The number of players playing your game: " + pCallback.m\_cPlayers);  
        \}  
    \}  
\}

完整的调用方法如下：

public class SteamScript : MonoBehaviour \{  
    **private CallResult**<NumberOfCurrentPlayers\_t> m\_NumberOfCurrentPlayers;  
   
    private void **OnEnable()** \{  
        if (SteamManager.Initialized) \{  
            m\_NumberOfCurrentPlayers = CallResult<NumberOfCurrentPlayers\_t>.**Create**(OnNumberOfCurrentPlayers);  
        \}  
    \}  
   
    private void **Update()** \{  
        if(Input.GetKeyDown(KeyCode.Space)) \{  
            SteamAPICall\_t handle = *SteamUserStats.GetNumberOfCurrentPlayers*();  
            m\_NumberOfCurrentPlayers.Set(handle);  
            Debug.Log("Called GetNumberOfCurrentPlayers()");  
        \}  
    \}  
   
    private void **OnNumberOfCurrentPlayers**(NumberOfCurrentPlayers\_t pCallback, bool bIOFailure) \{  
        if (pCallback.m\_bSuccess != 1 || bIOFailure) \{  
            Debug.Log("There was an error retrieving the NumberOfCurrentPlayers.");  
        \}  
        else \{  
            Debug.Log("The number of players playing your game: " + pCallback.m\_cPlayers);  
        \}  
    \}  
\}

关于SteamManager的工作原理，可参考之前链接文档中的相关模块。

三、涉及SDK中所有API的用法，前文链接中提供的Demo都有详细的演示，下边总结下自己主要使用的功能模块。

如：下边这段unity客户端代码即利用**OnGameOverlayActivated**获取当前steam窗口弹出回调来控制当前游戏主进程的暂停与恢复。

using UnityEngine;  
using Steamworks;

public class SteamScript : MonoBehaviour \{

**// 声明委托类**  
    **protected Callback<GameOverlayActivated\_t>**  m\_GameOverlayActivated;

// Use this for initialization  
    void **Start ()**

\{  
        if (SteamManager.Initialized)  
        \{  
            string name = ***SteamFriends.GetPersonaName***();   
        \}  
    \}  
   
    void **OnEnable()**  
    \{  
        if (SteamManager.Initialized)  
        \{

**    // 实例化委托，并把被委托方拥有的方法做为参数传入**  
            m\_GameOverlayActivated = **Callback<GameOverlayActivated\_t>.Create**(OnGameOverlayActivated);   
        \}  
    \}

**// 被委托方拥有的方法**  
    private void **OnGameOverlayActivated**(GameOverlayActivated\_t  pCallback)  
    \{  
        if (pCallback.m\_bActive != 0)  
        \{  
            Time.timeScale = 0;  
        \}else  
        \{  
            Time.timeScale = 1;  
        \}  
    \}

在项目的后台页面设定项目所需存储的用户信息，以及可自定义成就信息、排行榜信息等。同样这些操作也可以用代码直接完成。下边是完整的测试脚本：

using UnityEngine;  
using Steamworks;  
using System.Collections.Generic;  
   
public enum EClientGameState  
\{  
    k\_EClientGameCount,  
    k\_EClientGameWinner,  
    k\_EClientGameLoser,  
    k\_EClientGameAward,  
\};

// This is a port of **StatsAndAchievements.cpp** from *SpaceWar*, the official Steamworks Example.

public class SteamStatsAndAchievements : MonoBehaviour  
\{  
    \#region 单例  
    **private** static SteamStatsAndAchievements ins;  
   
    **public** static SteamStatsAndAchievements Ins  
    \{  
        get\{ return ins; \}  
    \}

\#endregion  
    void Awake()  
    \{  
        ins = this;  
    \}  
   
   
    private enum Achievement : int  
    \{  
        ACH\_WIN\_ONE\_GAME,  
        ACH\_WIN\_100\_GAMES,  
        ACH\_LEVEL1,  
        ACH\_LEVEL2,  
        ACH\_LEVEL3,  
        ACH\_LEVEL4,  
    \};  
   
    private Achievement\_t\[\] m\_Achievements = new Achievement\_t\[\] \{  
        new Achievement\_t(Achievement.ACH\_WIN\_ONE\_GAME, "初心者", ""),  
        new Achievement\_t(Achievement.ACH\_WIN\_100\_GAMES, "Champion", ""),  
        new Achievement\_t(Achievement.ACH\_LEVEL1, "LEVEL1", ""),  
        new Achievement\_t(Achievement.ACH\_LEVEL2, "LEVEL2", ""),  
        new Achievement\_t(Achievement.ACH\_LEVEL3, "LEVEL3", ""),  
        new Achievement\_t(Achievement.ACH\_LEVEL4, "LEVEL4", ""),  
    \};  
   
    public List<GameObject> gos;

// Our GameID  
    private CGameID m\_GameID;  
   
    // Did we get the stats from Steam?  
    private bool m\_bRequestedStats;  
    private bool m\_bStatsValid;  
   
    // Should we store stats this frame?  
    private bool m\_bStoreStats;  
   
    private SteamLeaderboard\_t m\_steamLeaderboard;  
    // Persisted Stat details  
    private int m\_nTotalGamesPlayed;  
    private int m\_nTotalNumWins;  
    private int m\_nTotalNumLosses;  
    private int m\_flGamePlayerAward;  
    private int m\_flMaxPlayerAward;  
   
    protected Callback<UserStatsReceived\_t> m\_UserStatsReceived;  
    protected Callback<UserStatsStored\_t> m\_UserStatsStored;  
    protected Callback<UserAchievementStored\_t> m\_UserAchievementStored;  
   
    protected CallResult<LeaderboardFindResult\_t> m\_LeaderboardFindResult;  
    protected CallResult<LeaderboardScoreUploaded\_t> m\_LeaderboardScoreUploaded;  
    protected CallResult<LeaderboardScoresDownloaded\_t> m\_LeaderboardScoresDownloaded;

void OnEnable()  
    \{  
        if (!SteamManager.Initialized)  
            return;  
   
        // Cache the GameID for use in the Callbacks  
        m\_GameID = new CGameID(SteamUtils.GetAppID());  
   
   
        m\_UserStatsReceived = Callback<UserStatsReceived\_t>.Create(OnUserStatsReceived);  
        m\_UserStatsStored = Callback<UserStatsStored\_t>.Create(OnUserStatsStored);  
        m\_UserAchievementStored = Callback<UserAchievementStored\_t>.Create(OnAchievementStored);  
   
        m\_LeaderboardFindResult = CallResult<LeaderboardFindResult\_t>.Create(OnLeaderboardFindResult);  
   
        m\_LeaderboardScoreUploaded = CallResult<LeaderboardScoreUploaded\_t>.Create(OnLeaerboardScoreUploaded);  
        m\_LeaderboardScoresDownloaded = CallResult<LeaderboardScoresDownloaded\_t>.Create(OnLeaderboardScoresDownloaded);  
        // These need to be reset to get the stats upon an Assembly reload in the Editor.  
        m\_bRequestedStats = false;  
        m\_bStatsValid = false;  
        SteamAPICall\_t handle = SteamUserStats.FindOrCreateLeaderboard("PlayerValue", ELeaderboardSortMethod.k\_ELeaderboardSortMethodDescending, ELeaderboardDisplayType.k\_ELeaderboardDisplayTypeNumeric);  
        m\_LeaderboardFindResult.Set(handle);  
   
    \}  
   
    private void OnLeaderboardScoresDownloaded(LeaderboardScoresDownloaded\_t pCallback, bool bIOFailure)  
    \{  
        if (pCallback.m\_hSteamLeaderboard == m\_steamLeaderboard)  
        \{  
            if (pCallback.m\_cEntryCount > 0)  
            \{  
                Debug.LogError("排行榜数据量：" + pCallback.m\_cEntryCount);  
                for (int i = 0; i < pCallback.m\_cEntryCount; i++)  
                \{  
                    LeaderboardEntry\_t leaderboardEntry;  
                    int\[\] details = new int\[pCallback.m\_cEntryCount\];  
                    SteamUserStats.GetDownloadedLeaderboardEntry(pCallback.m\_hSteamLeaderboardEntries, i, out leaderboardEntry, details, pCallback.m\_cEntryCount);  
                    Debug.LogError("用户ID：" + leaderboardEntry.m\_steamIDUser + "用户分数" + leaderboardEntry.m\_nScore + "用户排名" + leaderboardEntry.m\_nGlobalRank + "Details" + leaderboardEntry.m\_cDetails + "  " + SteamFriends.GetFriendPersonaName(leaderboardEntry.m\_steamIDUser));  
                    gos\[i\].transform.FindChild("name").GetComponent<UILabel>().text = leaderboardEntry.m\_nGlobalRank + "  " + SteamFriends.GetFriendPersonaName(leaderboardEntry.m\_steamIDUser);  
                    gos\[i\].transform.FindChild("score").GetComponent<UILabel>().text = leaderboardEntry.m\_nScore+"";  
                \}  
                  
            \}  
            else  
            \{  
                Debug.LogError("排行榜数据为空！");  
            \}  
        \}  
    \}  
   
    private void OnLeaerboardScoreUploaded(LeaderboardScoreUploaded\_t pCallback, bool bIOFailure)  
    \{  
        if (pCallback.m\_bSuccess != 1)  
        \{  
            UploadScore(PlayerControl.Ins.Award);  
   
        \}  
        //else if(pCallback.m\_hSteamLeaderboard!= m\_steamLeaderboard)  
        //\{  
        //    Debug.LogError("获取排行榜数据信息有误！！");  
        //\}  
        else  
        \{  
            Debug.LogError("成功上传价值数据：" + pCallback.m\_nScore + "榜内数据是否需要变更：" + pCallback.m\_bScoreChanged  
                + "新的排名：" + pCallback.m\_nGlobalRankNew + "上次排名：" + pCallback.m\_nGlobalRankPrevious);  
            gos\[gos.Count - 1\].transform.FindChild("name").GetComponent<UILabel>().text = pCallback.m\_nGlobalRankNew + "  " + SteamFriends.GetPersonaName();  
            gos\[gos.Count - 1\].transform.FindChild("score").GetComponent<UILabel>().text = pCallback.m\_nScore + "";  
            if (pCallback.m\_nGlobalRankPrevious == 0|| pCallback.m\_bScoreChanged != 0)  
            \{  
                  
            \}  
            DownloadLeaderboardEntries();  
        \}  
    \}  
   
    private void OnLeaderboardFindResult(LeaderboardFindResult\_t pCallback, bool bIOFailure)  
    \{  
        if (!SteamManager.Initialized)  
            return;  
        if (pCallback.m\_hSteamLeaderboard.m\_SteamLeaderboard == 0||pCallback.m\_bLeaderboardFound==0)  
        \{  
            Debug.LogError("There is no Leaderboard found");  
        \}else  
        \{  
            m\_steamLeaderboard = pCallback.m\_hSteamLeaderboard;  
            UploadScore(PlayerControl.Ins.Award);  
        \}  
          
    \}  
   
    public void UploadScore(int score)  
    \{  
        if (m\_steamLeaderboard.m\_SteamLeaderboard != 0)  
        \{  
            Debug.LogError("上传分数");  
            var handle = SteamUserStats.UploadLeaderboardScore(m\_steamLeaderboard, ELeaderboardUploadScoreMethod.k\_ELeaderboardUploadScoreMethodForceUpdate, score, null, 0);  
            m\_LeaderboardScoreUploaded.Set(handle);  
        \}  
    \}  
   
    public void DownloadLeaderboardEntries()  
    \{  
        if (m\_steamLeaderboard.m\_SteamLeaderboard != 0)  
        \{  
            Debug.LogError("请求排行榜数据");  
            var handle = SteamUserStats.DownloadLeaderboardEntries(m\_steamLeaderboard, ELeaderboardDataRequest.k\_ELeaderboardDataRequestGlobal, 1, 8);  
            m\_LeaderboardScoresDownloaded.Set(handle);  
        \}  
    \}  
   
    private void Update()  
    \{  
        if (!SteamManager.Initialized)  
            return;  
   
        if (!m\_bRequestedStats)  
        \{  
            // Is Steam Loaded? if no, can't get stats, done  
            if (!SteamManager.Initialized)  
            \{  
                m\_bRequestedStats = true;  
                return;  
            \}  
   
            // If yes, request our stats  
            bool bSuccess = SteamUserStats.RequestCurrentStats();  
   
            // This function should only return false if we weren't logged in, and we already checked that.  
            // But handle it being false again anyway, just ask again later.  
            m\_bRequestedStats = bSuccess;  
        \}  
   
        if (!m\_bStatsValid)  
            return;  
   
        // Get info from sources  
   
        // Evaluate achievements  
        foreach (Achievement\_t achievement in m\_Achievements)  
        \{  
            if (achievement.m\_bAchieved)  
                continue;  
            switch (achievement.m\_eAchievementID)  
            \{  
                case Achievement.ACH\_WIN\_ONE\_GAME:  
                    if (m\_nTotalNumWins != 0)  
                    \{  
                        UnlockAchievement(achievement);  
                    \}  
                    break;  
                case Achievement.ACH\_WIN\_100\_GAMES:  
                    if (m\_nTotalNumWins >= 100)  
                    \{  
                        UnlockAchievement(achievement);  
                    \}  
                    break;  
                case Achievement.ACH\_LEVEL1:  
                    if (m\_flMaxPlayerAward >= 25000)  
                    \{  
                        UnlockAchievement(achievement);  
                    \}  
                    break;  
                case Achievement.ACH\_LEVEL2:  
                    if (m\_flMaxPlayerAward >= 90000)  
                    \{  
                        UnlockAchievement(achievement);  
                    \}  
                    break;  
                case Achievement.ACH\_LEVEL3:  
                    if (m\_flMaxPlayerAward >= 200000)  
                    \{  
                        UnlockAchievement(achievement);  
                    \}  
                    break;  
                case Achievement.ACH\_LEVEL4:  
                    if (m\_flMaxPlayerAward >= 400000)  
                    \{  
                        UnlockAchievement(achievement);  
                    \}  
                    break;  
            \}  
        \}  
   
        //Store stats in the Steam database if necessary  
        if (m\_bStoreStats)  
        \{  
            // already set any achievements in UnlockAchievement  
   
            // set stats  
            SteamUserStats.SetStat("NumGames", m\_nTotalGamesPlayed);  
            SteamUserStats.SetStat("NumWins", m\_nTotalNumWins);  
            SteamUserStats.SetStat("NumLosses", m\_nTotalNumLosses);  
            SteamUserStats.SetStat("GamePlayerAward", m\_flGamePlayerAward);  
            SteamUserStats.SetStat("MaxPlayerAward", m\_flMaxPlayerAward);  
   
            bool bSuccess = SteamUserStats.StoreStats();  
            // If this failed, we never sent anything to the server, try  
            // again later.  
            m\_bStoreStats = !bSuccess;  
        \}  
    \}  
   
    //-----------------------------------------------------------------------------  
    // Purpose: Game state has changed  
    //-----------------------------------------------------------------------------  
    public void OnGameStateChange(EClientGameState eNewState)  
    \{  
        if (!m\_bStatsValid)  
            return;  
        //游戏场次  
        if (eNewState == EClientGameState.k\_EClientGameCount)  
        \{  
            m\_nTotalGamesPlayed++;  
        \}  
        //玩家价值（成就）  
        else if (eNewState == EClientGameState.k\_EClientGameAward)  
        \{  
            m\_flGamePlayerAward = PlayerControl.Ins.Award;  
            if (m\_flGamePlayerAward > m\_flMaxPlayerAward)  
                m\_flMaxPlayerAward = m\_flGamePlayerAward;  
        \}  
        //玩家获胜场次  
        else if (eNewState == EClientGameState.k\_EClientGameWinner)  
        \{  
            m\_nTotalNumWins++;  
        \}  
        //玩家失败场次  
        else  
        \{  
            m\_nTotalNumLosses++;  
        \}  
        // We want to update stats the next frame.  
        m\_bStoreStats = true;  
    \}  
   
    //-----------------------------------------------------------------------------  
    // Purpose: Unlock this achievement  
    //-----------------------------------------------------------------------------  
    private void UnlockAchievement(Achievement\_t achievement)  
    \{  
        achievement.m\_bAchieved = true;  
   
        // the icon may change once it's unlocked  
        //achievement.m\_iIconImage = 0;  
   
        // mark it down  
        SteamUserStats.SetAchievement(achievement.m\_eAchievementID.ToString());  
   
        // Store stats end of frame  
        m\_bStoreStats = true;  
    \}  
   
    //-----------------------------------------------------------------------------  
    // Purpose: We have stats data from Steam. It is authoritative, so update  
    //            our data with those results now.  
    //-----------------------------------------------------------------------------  
    private void OnUserStatsReceived(UserStatsReceived\_t pCallback)  
    \{  
        if (!SteamManager.Initialized)  
            return;  
   
        // we may get callbacks for other games' stats arriving, ignore them  
        if ((ulong)m\_GameID == pCallback.m\_nGameID)  
        \{  
            if (EResult.k\_EResultOK == pCallback.m\_eResult)  
            \{  
                Debug.Log("Received stats and achievements from Steam\\n");  
   
                m\_bStatsValid = true;  
   
                // load achievements  
                foreach (Achievement\_t ach in m\_Achievements)  
                \{  
                    bool ret = SteamUserStats.GetAchievement(ach.m\_eAchievementID.ToString(), out ach.m\_bAchieved);  
                    if (ret)  
                    \{  
                        ach.m\_strName = SteamUserStats.GetAchievementDisplayAttribute(ach.m\_eAchievementID.ToString(), "name");  
                        ach.m\_strDescription = SteamUserStats.GetAchievementDisplayAttribute(ach.m\_eAchievementID.ToString(), "desc");  
                        Debug.LogError(ach.m\_eAchievementID.ToString() + "  " + ach.m\_bAchieved + "  " + ach.m\_strName + "  " + ach.m\_strDescription);  
                    \}  
                    else  
                    \{  
                        Debug.LogWarning("SteamUserStats.GetAchievement failed for Achievement " + ach.m\_eAchievementID + "\\nIs it registered in the Steam Partner site?");  
                    \}  
                \}  
   
                // load stats  
                SteamUserStats.GetStat("NumGames", out m\_nTotalGamesPlayed);  
                SteamUserStats.GetStat("NumWins", out m\_nTotalNumWins);  
                SteamUserStats.GetStat("NumLosses", out m\_nTotalNumLosses);  
                SteamUserStats.GetStat("GamePlayerAward", out m\_flGamePlayerAward);  
                SteamUserStats.GetStat("MaxPlayerAward", out m\_flMaxPlayerAward);  
            \}  
            else  
            \{  
                Debug.Log("RequestStats - failed, " + pCallback.m\_eResult);  
            \}  
        \}  
    \}  
   
    //-----------------------------------------------------------------------------  
    // Purpose: Our stats data was stored!  
    //-----------------------------------------------------------------------------  
    private void OnUserStatsStored(UserStatsStored\_t pCallback)  
    \{  
        // we may get callbacks for other games' stats arriving, ignore them  
        if ((ulong)m\_GameID == pCallback.m\_nGameID)  
        \{  
            if (EResult.k\_EResultOK == pCallback.m\_eResult)  
            \{  
                Debug.Log("StoreStats - success");  
            \}  
            else if (EResult.k\_EResultInvalidParam == pCallback.m\_eResult)  
            \{  
                // One or more stats we set broke a constraint. They've been reverted,  
                // and we should re-iterate the values now to keep in sync.  
                Debug.Log("StoreStats - some failed to validate");  
                // Fake up a callback here so that we re-load the values.  
                UserStatsReceived\_t callback = new UserStatsReceived\_t();  
                callback.m\_eResult = EResult.k\_EResultOK;  
                callback.m\_nGameID = (ulong)m\_GameID;  
                OnUserStatsReceived(callback);  
            \}  
            else  
            \{  
                Debug.Log("StoreStats - failed, " + pCallback.m\_eResult);  
            \}  
        \}  
    \}  
   
    //void OnGUI()  
    //\{  
    //    if (GUI.Button(new Rect(10, 10, 50, 50), "reset"))  
    //    \{  
    //        SteamUserStats.ResetAllStats(true);  
    //        SteamUserStats.RequestCurrentStats();  
    //    \}  
   
    //\}  
   
    //-----------------------------------------------------------------------------  
    // Purpose: An achievement was stored  
    //-----------------------------------------------------------------------------  
    private void OnAchievementStored(UserAchievementStored\_t pCallback)  
    \{  
        // We may get callbacks for other games' stats arriving, ignore them  
        if ((ulong)m\_GameID == pCallback.m\_nGameID)  
        \{  
            if (0 == pCallback.m\_nMaxProgress)  
            \{  
                Debug.Log("Achievement '" + pCallback.m\_rgchAchievementName + "' unlocked!");  
            \}  
            else  
            \{  
                Debug.Log("Achievement '" + pCallback.m\_rgchAchievementName + "' progress callback, (" + pCallback.m\_nCurProgress + "," + pCallback.m\_nMaxProgress + ")");  
            \}  
        \}  
    \}  
   
    private class Achievement\_t  
    \{  
        public Achievement m\_eAchievementID;  
        public string m\_strName;  
        public string m\_strDescription;  
        public bool m\_bAchieved;  
   
        /// <summary>  
        /// Creates an Achievement. You must also mirror the data provided here in https://partner.steamgames.com/apps/achievements/yourappid  
        /// </summary>  
        /// <param name="achievement">The "API Name Progress Stat" used to uniquely identify the achievement.</param>  
        /// <param name="name">The "Display Name" that will be shown to players in game and on the Steam Community.</param>  
        /// <param name="desc">The "Description" that will be shown to players in game and on the Steam Community.</param>  
        public Achievement\_t(Achievement achievementID, string name, string desc)  
        \{  
            m\_eAchievementID = achievementID;  
            m\_strName = name;  
            m\_strDescription = desc;  
            m\_bAchieved = false;  
        \}  
    \}  
\}

EClientGameState作为自定义的成就类型划分，以区分预设成就，在玩家游戏状态发生改变时上传更新服务器端数据。提示下没接触过steamworks的小伙伴，value允许搭建自己的服务器做后台，也可以直接使用steam提供的后台作为服务器。后者类似于Unity提供的PlayerPrefs，数据存取十分简单。  
以上逻辑总体遵循前边所述的规则，**注册回调**后调用Callback<T>.Create()来绑定数据返回的后续操作。有两点要注意在使用排行榜上传数据时，需要指定排行榜的行为（分为none，保留玩家最佳成绩及总是替换玩家当前数据）。若使用ELeaderboardUploadScoreMethod.k\_ELeaderboardUploadScoreMethodKeepBest，需注意第一次上传时不会更新排行榜数据。这里测试后暂时还没找到强制更新排行榜数据的方法，所以采用了ELeaderboardUploadScoreMethod.k\_ELeaderboardUploadScoreMethodForceUpdate。

另一个要注意的点就是有的回调采用了handle的形式，每次调用需获取对应的句柄并使用Set方法设置句柄。这里最初没有注意采用数据存储一样的方式注册回调导致无法上传成功取得返回结果。

最后值得注意的一点是向项目后台上传项目元数据时要使用原生sdk中提供的工具，在sdk目录的tools文件夹下。根据steam提供给你的项目的两个id，修改对应的配置文件以后把所有项目元数据置于文件夹下利用命令行上传。这个在原生sdk的文档中有youtube视频教程说明。要注意的是视频中的命令无法全部上传成功，所以我尝试采用了数据库的select \*思路加了\*强行上传目录下全部文件，成功上传全部数据。

最后感谢github上开源的Steamworks.NET

[http_steamworks.github.io_gettingstarted]: http://steamworks.github.io/gettingstarted/
[https_blog.csdn.net_qq_42672770_article_details_104425473]: https://blog.csdn.net/qq_42672770/article/details/104425473
[https_blog.csdn.net_qq_42672770_article_details_104444771]: https://blog.csdn.net/qq_42672770/article/details/104444771
[https_blog.csdn.net_qq_42672770_article_details_104444894]: https://blog.csdn.net/qq_42672770/article/details/104444894
[https_blog.csdn.net_qq_42672770_article_details_104361853]: https://blog.csdn.net/qq_42672770/article/details/104361853