스팀 연동

Classic/VPC 환경에서 이용 가능합니다.

게임에서 플레이어의 스팀 계정을 이용한 인증 설정을 다음과 같은 시나리오를 통해 안내합니다.

• 스팀 계정으로 로그인 설정하기
• 기존 사용자 로그인 혹은 새 사용자 생성하기
• 익명 로그인에서 스팀 계정을 통한 플랫폼 로그인으로 사용자 업데이트하기

게임 내 플레이어에게 스팀 로그인 옵션을 제공하기 위해, 스팀웍스 파트너 포털에서 앱을 생성하고 사용자를 로그인시키고 세션 티켓을 얻기 위해 Steamworks.Net SDK를 설치해 주십시오.

스팀 계정 로그인 설정

1. 스팀웍스 문서를 따라 앱을 생성하고 앱 ID를 기록해 주십시오. Steamworks documentation.
2. 웹 API 키 문서를 사용한 인증을 따라 게시자 웹 API 키를 생성해 주십시오. Authentication using Web API Keys
3. Unity용 SDK를 설치하는 구체적인 지침에 따라 SteamWorks.Net SDK를 설치해 주십시오.
   1. SteamWorks.Net SDK Unity plugin 을 Import 해 주십시오.
   2. 프로젝트의 루트에 있는 steam_appid.txt를 열고 480을 자신의 앱 ID로 교체해 주십시오.
   3. 씬 안의 게임 오브젝트에 스팀 매니저 게임 컴포넌트를 추가해 주십시오. 스팀 라이브러리를 초기화할 것입니다.
   4. 테스트하기 전에, 스팀이 설치되어 있고 로그인되어 있는지, 개발 중인 프로젝트 라이브러리에 있는지 확인해 주십시오.

스팀 로그인

1. Steamworks.NET에서 최신 버전을 다운로드 후에 Unity Import해 주십시오.
   
2. 프로젝트 루트 폴더에 steam_appid.txt 파일을 생성 후에 스팀에서 발급받은 app ID 를 넣고 저장해 주십시오.
   
3. Users & Permissions > Manage Group > Create Group > Create Web API KEY 를 생성해 주십시오.
   
4. Steam APP ID 와 Web API 키를 게임팟 대시보드 > 연동 > 스팀란에 추가해 주십시오.
   

SteamManager 씬을 추가하고 해당 씬에 추가

Assets > Scripts > Steamworks.NET > SteamManager.cs를 Hierarchy의 빈 오브젝스를 생성 및 추가해 주십시오.

게임팟 로그인 추가

스팀 로그인을 완료 후에 스팀 세션 티켓을 signInWithCredential 를 통해 로그인 처리를 해주시면 됩니다.

NBaseSDK.NBase.signInWithToken("steam", memberId, sessionTicket, (user, error) =>
{
    try
    {
        if(error != null)
        { 
            Debug.Log("Login Success - " + user.ToString());
        }
        memberId = user.Id;
        
    }
    catch (Exception ex)
    {
        Debug.Log($"An exception occurred during sign-in: {ex.Message}");
    }
});

게임내 코드 추가 예제

private Callback<GetAuthSessionTicketResponse_t> m_GetAuthSessionTicketResponse;
private byte[] m_Ticket;
private uint m_pcbTicket;
private HAuthTicket m_HAuthTicket;

// NBase Initialize 완료 후에 실행해 주세요.
private void Initialize()
{
    try
    {
        InitializeSteamAuth();
        
        // Steam이 초기화되었는지 확인
        if (SteamManager.Initialized)
        {
            // Steam 로그인 상태 확인
            if (SteamUser.BLoggedOn())
            {
                // 이미 로그인된 경우
                CSteamID steamId = SteamUser.GetSteamID();
                string steamName = SteamFriends.GetPersonaName();
                
                Log($"Steam User Connected - Name: {steamName}, SteamID: {steamId}");
    
            }
            else
            {
                // 로그인되지 않은 경우
                Log("Steam user not logged in. Opening Steam login overlay.");
                ShowBox("Steam must be running to play this game.");
            }
        }
        else
        {
            Log("Steam is not initialized. Please make sure Steam is running.");
            ShowBox("Steam must be running to play this game.\nPlease start Steam and restart the game.");
        }
    }
    catch (Exception ex)
    {
        Log($"Failed to initialize Steam login: {ex.Message}");
        ShowBox("Failed to connect to Steam. Please restart the game.");
    }
}
private void OnDestroy()
{
    CleanupAuthTicket();
}

private void InitializeSteamAuth()
{
    if (!SteamManager.Initialized)
    {
        Log("Steam is not initialized. Skipping auth ticket generation.");
        return;
    }

    try
    {
        // Create callback for auth ticket response
        m_GetAuthSessionTicketResponse = Callback<GetAuthSessionTicketResponse_t>.Create(OnGetAuthSessionTicketResponse);

        // Initialize ticket buffer
        m_Ticket = new byte[1024];
        
        // Create SteamNetworkingIdentity instance
        SteamNetworkingIdentity networkingIdentity = new SteamNetworkingIdentity();
        
        // Get auth session ticket with networking identity
        m_HAuthTicket = SteamUser.GetAuthSessionTicket(
            m_Ticket, 
            1024, 
            out m_pcbTicket,
            ref networkingIdentity
        );

        if (m_HAuthTicket == HAuthTicket.Invalid)
        {
            throw new Exception("Failed to get valid Steam auth ticket");
        }

        Log($"Successfully generated Steam auth ticket. Ticket size: {m_pcbTicket} bytes");
    }
    catch (Exception ex)
    {
        Log($"Error during Steam auth ticket generation: {ex.Message}");
        CleanupAuthTicket();
    }
}

private void OnGetAuthSessionTicketResponse(GetAuthSessionTicketResponse_t pCallback)
{
    try
    {
        if (pCallback.m_hAuthTicket != m_HAuthTicket)
        {
            Log("Received response for different auth ticket");
            return;
        }

        // Resize to buffer of actual ticket size
        System.Array.Resize(ref m_Ticket, (int)m_pcbTicket);

        // Format as Hex
        System.Text.StringBuilder sb = new System.Text.StringBuilder();
        foreach (byte b in m_Ticket) 
        {
            sb.AppendFormat("{0:x2}", b);
        }
        CSteamID steamId = SteamUser.GetSteamID();
        sessionTicket = sb.ToString();
        NBaseSDK.NBase.signInWithToken("steam", steamId.ToString(), sessionTicket, (user, error) =>
        {
            try
            {
                if(error != null)
                { 
                    Debug.Log("Login Success - " + user.ToString());
                }
                memberId = user.Id;
               
            }
            catch (Exception ex)
            {
                Debug.Log($"An exception occurred during sign-in: {ex.Message}");
            }
        });

        switch (pCallback.m_eResult)
        {
            case EResult.k_EResultOK:
                Log("Steam auth ticket successfully generated");
                break;
            case EResult.k_EResultInvalidParam:
                Log("Steam auth ticket generation failed: Invalid parameters");
                break;
            case EResult.k_EResultLimitExceeded:
                Log("Steam auth ticket generation failed: Limit exceeded");
                break;
            default:
                Log($"Steam auth ticket generation failed: {pCallback.m_eResult}");
                break;
        }
    }
    catch (Exception ex)
    {
        Log($"Error processing auth ticket response: {ex.Message}");
    }
}

private void CleanupAuthTicket()
{
    if (m_HAuthTicket != HAuthTicket.Invalid)
    {
        try
        {
            SteamUser.CancelAuthTicket(m_HAuthTicket);
            m_HAuthTicket = HAuthTicket.Invalid;
            m_Ticket = null;
            Log("Steam auth ticket cleaned up successfully");
        }
        catch (Exception ex)
        {
            Log($"Error cleaning up auth ticket: {ex.Message}");
        }
    }
}

자동 로그인 처리 예제

자동 로그인 처리를 하기 위해서는 먼저 로그인 여부를 확인하는 예제입니다.

 NBaseSDK.NBase.signInLastLoggedIn((user, error) =>
{
      if (error != null)
      {
            // 자동 로그인이 안될 경우 일반 로그인 처리
             NBaseSDK.NBase.signInWithToken("steam", steamId.ToString(), sessionTicket, (user, error) =>
            {
                try
                {
                    if(error != null)
                    { 
                        Debug.Log("Login Success - " + user.ToString());
                    }
                    
                }
                catch (Exception ex)
                {
                    Debug.Log($"An exception occurred during sign-in: {ex.Message}");
                }
            }); 
       } 
       else if(user != null)
       {
            // 자동 로그인 성공
            Debug.Log("Login Success - " + user.ToString());
       }
}