Stats と Achievements

void MyGameClass::Initialize()
{
    // ...
    SteamUserStats()->RequestCurrentStats();
    STEAM_CALLBACK( MyGameClass, OnUserStatsReceived, UserStatsReceived_t );
}

void MyGameClass::OnUserStatsReceived()
{
    // stats/achievements を反復処理し、必要なゲーム データを初期化する。
    // m_achievementIds が実績の「API 名」の配列と仮定する。
    for (int i = 0; i < m_achievementIds.length; i++)
    {
        const char *achievementName = SteamUserStats()->GetAchievementDisplayAttribute(m_achievementIds[i], "name");
        const char *description = SteamUserStats()->GetAchievementDisplayAttribute(m_achievementIds[i], "desc");
        bool hidden = SteamUserStats()->GetAchievementDisplayAttribute(m_achievementIds[i], "hidden");
        bool isUnlocked;
        SteamUserStats()->GetAchievement(m_achievementIds[i], &isUnlocked);
        // 必要な実績の初期化を行う...
    }
}

auto asyncBlock = std::make_unique<XAsyncBlock>();
asyncBlock->context = nullptr;
asyncBlock->callback = [](XAsyncBlock* asyncBlock)
{
    // XAsyncBlock* の所有権を引き継ぐ
    std::unique_ptr<XAsyncBlock> asyncBlockPtr{ asyncBlock }; 

    XblAchievementsResultHandle resultHandle;
    auto hr = XblAchievementsGetAchievementsForTitleIdResult(asyncBlock, &resultHandle);

    if (SUCCEEDED(hr))
    {
        const XblAchievement* achievements = nullptr;
        size_t achievementsCount = 0;
        hr = XblAchievementsResultGetAchievements(resultHandle, &achievements, &achievementsCount);

        for (size_t i = 0; i < achievements.length; i++)
        {
            auto name = achievement[i].name;
            char description[256];
            char progress[4] = "100";
            if (achievement[i].progressState == XblAchievementProgressState::Achieved)
            {
                strcpy(description, achievement[i].unlockedDescription);
            }
            else
            {
                strcpy(description, achievement[i].lockedDescription);
                strcpy(progress, achievement[i].progression.requirements[0].currentProgressValue);
            }
            // このデータを使って実績を初期化する...
        }

        // ハンドルの使用が終わったら閉じる。これは実績リストをメモリから解放する。
        XblAchievementsResultCloseHandle(resultHandle);
        achievements = nullptr; 
        // 代わりに、ハンドルを閉じずに保存することもできる。  
        // ハンドルをコピーする必要がある場合は、XblAchievementsResultDuplicateHandle() を呼び出す
    }
};

// m_xblContext は適切に初期化された XBOX services Context ハンドルと仮定する。
uint64_t xuid;
XblContextGetXboxUserId(m_xblContext, &xuid);

HRESULT hr = XblAchievementsGetAchievementsForTitleIdAsync(
    m_xblContext,
    xuid, 
    m_titleId, // これはゲームのタイトル ID を保持する uint32_t と仮定する。
    XblAchievementType::Persistent, // achievementType: 通常は XblAchievementType::Persistent を使用する。
    false, //unlockedOnly: true の場合、解除された実績のみを返す。
    XblAchievementOrderBy::DefaultOrder, // orderBy: 入ってくる実績リストの並び順。 
    0, // skipItems: スキップする実績の数。 
    0, // maxItems: すべての実績を取得する / ページ分割を無効にするには 0 を設定する。
    asyncBlock.get()
);
if (SUCCEEDED(hr))
{
    // 呼び出しが成功したので、コールバックが所有権を引き継ぐため、XAsyncBlock* の std::unique_ptr の所有権を解放する。
    // 呼び出しが失敗した場合、std::unique_ptr は所有権を保持し、XAsyncBlock* を削除する。
    asyncBlock.release();
}

void MyGame::UpdateAchievement(const char *achievementApiName, const char *statApiName, int diff, int target)
{
    bool isCompleted;
    int value;
    bool result = SteamUserStats()->GetAchievement(achievementApiName, &isCompleted);
    if (!result) {
        // エラーを処理する。
    }

    result = SteamUserStats()->GetStat(statApiName, &value);
    if (!result) {
        // エラーを処理する。
    }

    SteamUserStats()->SetStat(statApiName, value + diff);
    
    if (!isCompleted && value + diff >= target)
    {
             // 実績を解除する。
        SteamUserStats()->SetAchievement(achievementApiName);
        SteamUserStats()->StoreStats();
    }
}

// 次のチェックポイントで...
if(!SteamUserStats()->StoreStats()) {
    // エラーを処理する。
}

void MyGame::UpdateAchievement(const std::string& achievementId, int diff, int target)
{
    // この関数は、保存されている場所から指定された実績の進行を返すと仮定する。
    auto previousValue = MyGetAchievementProgress(achievementId);
    // 進行状況を他の場所に保存している場合は、そこでも必ず更新すること！繰り返しになるが、これは 
    // 進行状況値を保存されている場所で更新するために書いた関数と仮定する。
    MySetAchievementProgress(previousValue + diff);
    // diff の値を追加した後にユーザーが到達したターゲットの割合を計算する。
    uint32_t percentComplete = (previousValue + diff) / target;

    auto async = std::make_unique<XAsyncBlock>();
    async->context = nullptr;
    async->callback = [](XAsyncBlock *async)
    {
        // XAsyncBlock* の所有権を引き継ぐ
        std::unique_ptr<XAsyncBlock> asyncBlockPtr{ async }; 

        HRESULT result = XAsyncGetStatus(async, true);

        if (SUCCEEDED(result))
        {
            // 成功！
        }
        else
        {
            if (result == HTTP_E_STATUS_NOT_MODIFIED)
            {
                // 実績はすでに完了しているか、以前により高い値に設定されていたため、
                // 変更されていない。
            }
            else
            {
                // エラーを処理する。
            }
        }
    };

    // m_xblContext は適切に初期化された XBOX services Context ハンドルと仮定する。
    uint64_t xuid;
    XblContextGetXboxUserId(m_xblContext, &xuid);
    HRESULT hr = XblAchievementsUpdateAchievementAsync(
        m_xblContext,
        xuid,
        achievementId.c_str(),
        percentComplete,
        async
    );

    if (SUCCEEDED(hr))
    {
        // 呼び出しが成功したので、コールバックが所有権を引き継ぐため、XAsyncBlock* の std::unique_ptr の所有権を解放する。
        // 呼び出しが失敗した場合、std::unique_ptr は所有権を保持し、XAsyncBlock* を削除する。
        asyncBlock.release();
    }
}