Steam Integration

// External Platform Integration Module C API example. In C++, call the vtable
// methods on the pointer returned by CreateParam directly (param->SetGameId, etc.).
// (In C, use the Stove_IModuleXxx_SetYyy flat accessors from api_module_flat.h.)
#include "api_module.h"
#include "api_module_types.h"
#include <cwchar>
#include <string>
#include <vector>

extern const wchar_t* g_GameId;
extern const wchar_t* g_SteamSessionToken; // Issued fresh every time
extern const wchar_t* g_SteamAppId;
extern const wchar_t* g_SteamUserId;

void StartPcsdk();            // Boot PCSDK3 (step 7, see PCSDK3 docs)

// Screen and game functions you implement yourself
void ShowNoticeUI(const std::wstring& title, const std::wstring& body);  // exits the game on confirm
void QuitGame();
std::wstring FormatLocalDate(int64_t unixMilliseconds);

// Example view model — copy the values you need before the callback returns.
struct TermsSection
{
    std::wstring title;
    std::wstring text;
    int64_t      enforcedDt = 0;
    bool         mustAgree  = false;   // AgreeType == L"FIRST_MUST"
};

static std::vector<TermsSection> g_TermsSections;
void ShowGameTermsUI(const std::vector<TermsSection>& sections);

// The callback convention must be __cdecl
void __cdecl OnInit(const IModuleAPICallbackResult* cb);
void __cdecl OnGameChecker(const IModuleAPICallbackResult* cb,
                           const IModuleGameCheckerForSteamOutcome* outcome);
void __cdecl OnFetchTerms(const IModuleAPICallbackResult* cb,
                          const IModuleFetchGameTermsForSteamOutcome* outcome);
void __cdecl OnAgreeTerms(const IModuleAPICallbackResult* cb,
                          const IModuleAgreeToGameTermsForSteamOutcome* outcome);

// Game entry check request (create -> fill -> call -> clean up)
void RequestGameChecker()
{
    auto* param = static_cast<IModuleGameCheckerForSteamParam*>(
        Stove_APIModule_CreateParam(k_EStoveAPIModuleTypeKind_GameCheckerForSteamParam));
    if (param == nullptr) return;

    param->SetGameId(g_GameId);
    param->SetSteamSessionToken(g_SteamSessionToken);

    Stove_APIModule_GameCheckerForSteam(param, OnGameChecker, nullptr);
    param->Destroy();
}

// Fetch terms request (AgType is fixed to the Steam game service terms = 1 Steam)
void RequestFetchTerms()
{
    auto* param = static_cast<IModuleFetchGameTermsForSteamParam*>(
        Stove_APIModule_CreateParam(k_EStoveAPIModuleTypeKind_FetchGameTermsForSteamParam));
    if (param == nullptr) return;

    param->SetGameId(g_GameId);
    param->SetAgType(k_EStoveFetchGameTermsForSteamAgType_Steam);

    Stove_APIModule_FetchGameTermsForSteam(param, OnFetchTerms, nullptr);
    param->Destroy();
}

void __cdecl OnInit(const IModuleAPICallbackResult* cb)
{
    const IModuleAPIResult* result = (cb != nullptr) ? cb->GetResult() : nullptr;
    if (result == nullptr || !result->IsSuccessful())
    {
        // Init failure notice (developer UI)
        return;
    }
    RequestGameChecker();
}

void __cdecl OnGameChecker(const IModuleAPICallbackResult* cb,
                           const IModuleGameCheckerForSteamOutcome* outcome)
{
    const IModuleAPIResult* result = (cb != nullptr) ? cb->GetResult() : nullptr;

    // Judge success with IsSuccessful()
    if (result != nullptr && result->IsSuccessful())
    {
        // Obtain outcome->GetAccessToken() etc. -> boot PCSDK3 (step 7)
        StartPcsdk();
        return;
    }

    // Get the branching code with GetExternalError() (not GetResultCode())
    const int32_t externalError = (cb != nullptr) ? cb->GetExternalError() : 0;
    switch (externalError)
    {
    case k_EStoveGameCheckerForSteamResultCode_NotAgreeTerms: // 406401
        // This callback carries no terms body. Call the terms lookup once more.
        RequestFetchTerms();
        break;

    case k_EStoveGameCheckerForSteamResultCode_GameRestrict: // 403201
    {
        // The result object supplies the restriction notice text.
        const IModuleGameCheckerForSteamRestrictInfo* info =
            (outcome != nullptr) ? outcome->GetRestrictInfo() : nullptr;
        if (info != nullptr)
        {
            std::wstring title = info->GetBanTypeLabel();
            std::wstring body  = info->GetBlockReasonComment();
            body += L"\nRestriction period ";
            body += FormatLocalDate(info->GetStartDt());
            body += L" ~ ";
            body += FormatLocalDate(info->GetEndDt());

            ShowNoticeUI(title, body);
        }
        else
        {
            ShowNoticeUI(L"Game access restricted", L"You cannot play this game. Please contact customer support.");
        }
        break;
    }
    case k_EStoveGameCheckerForSteamResultCode_GameServerMaintenance: // 503100
    {
        // The result object supplies the maintenance notice text.
        const IModuleGameCheckerForSteamMaintenanceInfo* info =
            (outcome != nullptr) ? outcome->GetMaintenanceInfo() : nullptr;
        if (info != nullptr)
        {
            std::wstring title = info->GetTitle();
            std::wstring body  = info->GetMsg();
            body += L"\nMaintenance window ";
            body += FormatLocalDate(info->GetStartDt());
            body += L" ~ ";
            body += FormatLocalDate(info->GetEndDt());

            ShowNoticeUI(title, body);
        }
        else
        {
            ShowNoticeUI(L"Server maintenance", L"The server is under maintenance. Please try again later.");
        }
        break;
    }
    default:
        // 49500/400000/401000/404xxx/500xxx etc.: no extra info, so you decide the wording.
        ShowNoticeUI(L"Connection error", L"A temporary error occurred. Please try again later.");
        break;
    }
}

void __cdecl OnFetchTerms(const IModuleAPICallbackResult* cb,
                          const IModuleFetchGameTermsForSteamOutcome* outcome)
{
    const IModuleAPIResult* result = (cb != nullptr) ? cb->GetResult() : nullptr;
    if (result == nullptr || !result->IsSuccessful() || outcome == nullptr)
    {
        ShowNoticeUI(L"Terms lookup failed", L"Could not load the service terms.");
        return;
    }

    // The pointers go invalid once the callback returns, so copy the values into the view model.
    g_TermsSections.clear();

    const uint32_t count = outcome->GetContentCount();
    for (uint32_t i = 0; i < count; ++i)
    {
        const IModuleFetchGameTermsForSteamContent* c = outcome->GetContentAt(i);
        if (c == nullptr) continue;

        TermsSection section;
        section.title      = (c->GetTitle() != nullptr) ? c->GetTitle() : L"";
        section.text       = (c->GetText()  != nullptr) ? c->GetText()  : L"";
        section.enforcedDt = c->GetEnforcedDt();

        // Decide the mandatory flag by AgreeType, not by the array order.
        const wchar_t* agreeType = c->GetAgreeType(); // "FIRST_MUST" / "NONE"
        section.mustAgree = (agreeType != nullptr && wcscmp(agreeType, L"FIRST_MUST") == 0);

        g_TermsSections.push_back(std::move(section));
    }

    // Show the screen. The consent result comes back through OnUserAgreed / OnUserDeclined below.
    ShowGameTermsUI(g_TermsSections);
}

// Your UI calls this when the user presses Agree.
void OnUserAgreed()
{
    auto* param = static_cast<IModuleAgreeToGameTermsForSteamParam*>(
        Stove_APIModule_CreateParam(k_EStoveAPIModuleTypeKind_AgreeToGameTermsForSteamParam));
    if (param == nullptr) return;

    // Per-item consent values are not sent. Submit once per game.
    param->SetGameId(g_GameId);
    param->SetSteamSessionToken(g_SteamSessionToken);

    Stove_APIModule_AgreeToGameTermsForSteam(param, OnAgreeTerms, nullptr);
    param->Destroy();
}

// Without agreeing, the user cannot enter the game.
void OnUserDeclined()
{
    QuitGame();
}

void __cdecl OnAgreeTerms(const IModuleAPICallbackResult* cb,
                          const IModuleAgreeToGameTermsForSteamOutcome* outcome)
{
    const IModuleAPIResult* result = (cb != nullptr) ? cb->GetResult() : nullptr;
    if (result == nullptr || !result->IsSuccessful())
    {
        // Re-calling while the submission has failed makes 406401 repeat.
        ShowNoticeUI(L"Terms agreement failed", L"Could not process the terms agreement. Please try again later.");
        return;
    }

    const wchar_t* guid = (outcome != nullptr) ? outcome->GetGuid() : nullptr;
    (void)guid;

    // The guid needs no separate handling — re-call the game entry check right away
    RequestGameChecker();
}

void GameMain()
{
    // 1) Issue the Steam session token (fresh every time)
    // g_SteamSessionToken = SteamUser()->GetAuthTicketForWebApi(...);

    // 2) Initialize
    auto* initParam = static_cast<IModuleAPIInitializeParam*>(
        Stove_APIModule_CreateParam(k_EStoveAPIModuleTypeKind_APIInitializeParam));
    if (initParam == nullptr) return;

    initParam->SetEnvironment(L"LIVE");
    initParam->SetPlatformName(L"STEAM");   // Fixed value
    initParam->SetSteamAppId(g_SteamAppId);
    initParam->SetSteamUserId(g_SteamUserId);

    Stove_APIModule_Initialize(initParam, OnInit, nullptr);
    initParam->Destroy();

    // 3) Callback pump (game main thread)
    while (IsGameRunning())
    {
        Stove_APIModule_RunCallback();
        // After booting PCSDK3, also call Base_RunCallback()
        // ... game frame processing ...
    }

    // 4) Clean up (caller destroys synchronously returned objects)
    IModuleAPIResult* unInit = Stove_APIModule_UnInitialize();
    if (unInit != nullptr) unInit->Destroy();
}