- Cập nhật lần cuối
This guide covers the basic integration flow from SDK initialization to termination.
Basic SDK Integration
Mobile SDK
This guide covers the basic flow for integrating the STOVE platform in a mobile environment (STOVE Mobile SDK).
This page covers only the 5 core steps of the boot flow.
ㆍ Auth.initialize → AuthUI.setProviders → AuthUI.login → User.setGameProfile → Auth.AccessToken Proceed in order.
ㆍ Additional features such as push notifications, coupons, pop-ups, deep links, and Vietnam regulations are covered separately in 기능별 가이드.
Overview
- The STOVE platform provides integrated services that simplify game launches.
- By integrating the STOVE Mobile SDK (hereinafter referred to as Mobile SDK) into your game, you can easily incorporate authentication, operations, and payment features.
- The Mobile SDK can be used in four build environments: Android (Kotlin/Java), iOS, Unity, and Unreal.
- The Auth/AuthUI module handles integrated login and automatically processes device registration, identity verification, terms of service agreement, and push registration with a single
AuthUI.logincall. - Detailed options for the entire authentication and account management flow (direct login, account conversion, manual identity verification calls, etc.) are covered in 로그인 가이드.
Prerequisites
Before proceeding with this guide, the following items must be prepared.
| Item | Description | Note |
|---|---|---|
| Partners Mobile Market Information | Package name/Bundle ID used as an identifier during SDK initialization. Must be pre-registered in Partners. | Publishing Center > Game Entry Management |
| Provider Authentication Channels | Authentication channels that the game will support (STOVE, Google, Apple, Facebook, etc.). The registration order in Partners AuthUI.setProviders matches the input order. |
Integration guide for each Provider |
| SDK Version | Apply STOVE Mobile SDK 2.x or higher | Environment Setup Guide |
| Build Environment Setup | SDK dependency, manifest, and Info.plist settings for each environment: Android (Gradle)/iOS (Xcode)/Unity/Unreal | Platform-specific environment guide |
Integration Flow
The Mobile SDK boot flow consists of 4 core calls and an automatic processing area.
- Game Start Sequence
- When the app launches, initialize the SDK with
Auth.initialize. At this stage, app updates and game maintenance checks are also performed. - Register the authentication channels the game will support with
AuthUI.setProviders. The order becomes the order in which the login screen is displayed. - Call
AuthUI.loginto display the integrated login screen and receive an AccessToken. - After login is complete, pass character and world information to the SDK with
User.setGameProfile.
- When the app launches, initialize the SDK with
- Flow Automatically Processed within AuthUI.login
- With a single integrated login call, new device registration, mandatory identity verification, terms of service agreement, and push registration are processed together.
- The game does not need to call these items directly. Separate calls are only required when displaying them again in in-game settings.
- During Gameplay
- Once character settings are finished, enter the main game screen.
- Since the SDK automatically refreshes the AccessToken at 80% of its expiration time, do not cache the token; instead, query it every time with
Auth.AccessTokento use it.
Integration Details
This guide provides the 5 core steps of the Mobile SDK boot flow with step-by-step scenarios and code examples.
1. SDK Initialization (Auth.initialize)
This is the step to acquire the initial information required to use the service. Initialization must be completed before subsequent login, payment, and operation features can be used.
- Call Conditions
- Call once when the app starts.
- Must be called before any other Mobile SDK API.
- How it works
- Retrieves service settings registered in Partners (
service_id,market_game_id). - Checks whether an app update is required (
AppUpdateError30004) and whether the game is under maintenance (MaintenanceError30003). - If you pass the received
ResulttoOperationUI.handleResultas is, the maintenance/app update notice UI will be displayed automatically. (No manual processing required)
- Retrieves service settings registered in Partners (
- Sequence Diagram
- Sample Code
- For full sample code by platform (Unity / Unreal / Android (Kotlin · Java) / iOS), refer to the 로그인 가이드 — 1. 초기화 (Auth.initialize) section.
App updates and game maintenance are handled automatically by the SDK
ㆍ You do not need to analyze the Auth.initialize results yourself to create a notice screen.
ㆍ If you pass the received Result to OperationUI.handleResult as is, the maintenance (30003) and app update (30004) UI will be displayed automatically.
ㆍ Continue the next step (login) flow within the callback.
2. Setting Authentication Channels (AuthUI.setProviders)
AuthUI.loginRegister the authentication channels (Providers) that the game will support before calling this. The order of the array passed determines the display order on the login screen.
- Prerequisites
- Execute after
Auth.initializeis complete and before callingAuthUI.login. - Registration is only required once per game.
- Execute after
- How it works
- Passes the list of Providers supported by the game to the SDK.
- Only channels pre-registered in Partners will function correctly. Adding unregistered channels will not authenticate during login.
- The Email Provider is displayed by default without needing separate addition. (Email Provider is mandatory for Login Screen Type B)
- Sample Code
- For full sample code by platform (Unity / Unreal / Android (Kotlin · Java) / iOS), refer to the 로그인 가이드 — 2. Provider 설정 (setProvider) section.
Must be executed before calling AuthUI.login.
ㆍ If you call AuthUI.login while Providers are empty, the user will not be able to select an authentication channel.
ㆍ The order in which you add them is the order they appear on the screen, so arrange them according to your marketing priorities.
3. Integrated Login (AuthUI.login)
This step handles everything at once, from displaying the login screen to issuing an AccessToken, device registration, identity verification, terms agreement, and push registration.
- Prerequisites
- Call after both
Auth.initializeandAuthUI.setProvidersare complete. - If an existing AccessToken exists, it will be processed as an auto-login; otherwise, the login screen will be displayed to the user.
- Call after both
- How it works
- Displays the integrated login UI and performs authentication using the Provider selected by the user.
- After authentication is complete, it issues/refreshes the AccessToken and passes user information via a callback.
- The items in the table below are all processed in a single call.
- Flows automatically handled within AuthUI.login
| Feature | Automatic Display Timing | Cases Requiring Separate Calls |
|---|---|---|
| Device Registration/Management | Automatically displayed when a new device needs to be registered | When manually displaying the device management UI from in-game settings |
| Identity Verification | Automatically displayed when verification is required by law/policy | When forcing re-verification before entering payment/sensitive features |
| Terms Agreement | Automatically displayed when a user who has not agreed enters | — |
| Push Registration | Automatically processed upon completion of login, token refresh, or account linking | — |
- Sequence Diagram
- Sample Code
- For full sample code by platform (Unity / Unreal / Android (Kotlin · Java) / iOS), refer to the 로그인 가이드 — 3. 통합 로그인 (AuthUI.login) section.
Items processed automatically do not need to be called separately
ㆍ Device registration, identity verification, terms, and push registration are handled automatically in one AuthUI.login call.
ㆍ Only call them when you need to display them again from in-game settings.로그인 가이드Please refer to the individual call section for each to call them directly.
4. Character/World Settings (User.setGameProfile)
After login is complete, pass the user's character and world information to the SDK. The entered information is used by each feature (coupon/popup/billing/push) to distinguish between worlds and characters.
- Call Conditions
AuthUI.loginCall this after success, right before entering the game's main page.- Call it again when the user changes characters or connects to a different world.
- Operation Method
characterNumberandworldIdas aGameProfileobject and set it inAccessToken.user.- For games that do not support worlds, you can pass
worldIdasnull. However, at least one default world must be registered in Partners. - The SDK does not check the validity of the values (whether they are null), so please perform null checks on the game side.
- Sample Code
- For the full sample code for each platform for both world-supporting and non-world-supporting games, please refer to the 로그인 가이드 — 4. 캐릭터 설정 (setGameProfile) section.
Character settings are mandatory
ㆍ If character settings are not configured, features based on worlds/characters set in Partners (coupons/popups/billing/push) will not function correctly.
ㆍ Even for games that do not support worlds, you must register at least one default world in Partners, and then call it by passing worldIdas null.
5. Using AccessToken (Auth.AccessToken)
This is the step to retrieve the token used by the game to call SDK features after character settings are configured.
- Call Condition
- Call it whenever an AccessToken is required while the game is running.
- Do not cache the token value as a variable within the game; fetch it anew each time it is needed.
- Operating Principle
- The SDK automatically refreshes the AccessToken when it reaches 80% of its expiration time.
- Since automatic refresh only works while the process is running, you must always use
Auth.AccessTokento receive the latest value. - If the AccessToken is
null, it means the user is logged out, so please redirect them to the login flow.
- Sample Code
- For full sample code by platform (Unity / Unreal / Android (Kotlin · Java) / iOS), please refer to the 로그인 가이드 — SDK 토큰 관리 section.
Always fetch tokens anew before use
ㆍ Since the SDK automatically refreshes at the 80% expiration mark, continuing to use a cached token may cause you to miss the refreshed token.
ㆍ If the AccessToken is null, it means the user is logged out. AuthUI.login again to redirect the user to the re-login flow.
PC SDK
This guide explains the basic flow for integrating the Stove platform in a PC environment (PCSDK3).
- The Stove platform provides integrated services that simplify game launches.
- By integrating the STOVE PC SDK (hereinafter PC SDK) into your game, you can easily incorporate Stove platform services.
- The STOVE PC Base SDK (hereinafter Base SDK) is a required module that provides the fundamental functions of Stove platform services.
The Base SDK is a prerequisite for all PC SDK features.
ㆍ The Base SDK is a module that must be integrated to use Stove platform services.
ㆍ Other PC SDK modules will not function if the Base SDK is not initialized.
ㆍ The Base SDK is applied via client integration.
Prerequisites
Please complete the 개발 환경 설정 process before proceeding with this guide. You must finish the Getting Started process to ensure the following flow proceeds without issues.
Fullscreen Mode Restrictions
ㆍ If you are using the View SDK (pop-up) or IAP SDK (purchase window) modules, there are restrictions regarding the game's Fullscreen mode.
ㆍ For more details, please refer to the integration overview for each module.
ㆍ These restrictions do not apply if you are not using the View SDK or IAP SDK.
Integration Flow
The Base SDK integration flow is as follows.
- Game Start Sequence
- Verify that the game was launched from the launcher when the game starts.
- Initialize the Base SDK when the game starts.
- Configure an API callback execution loop so that whenever PC SDK APIs are executed, any callbacks loaded in the callback queue are executed at each cycle.
- Implement selectively according to the game after configuring the API callback execution loop
- Set the language to be used in the PC SDK.
- Character/World settings (Register the currently connected worldId and characterNumber with the PC SDK.)
- Integrate over-immersion prevention features.
- Integrate game time selection features.
- Features that can be used selectively while the game is running
- Obtain the current user's Game Access token.
- Obtain current user information.
- Obtain the current user's GDS information.
- Obtain the current user's Signin information.
- Register a Game Access token refresh notification callback. (The token is automatically refreshed within the SDK, and the registered callback is called at the time of refresh.)
- Game Exit Sequence
- When the user exits the game, ensure the Base SDK is cleaned up before the game finally terminates.
Integration Details
We provide the general scenario for integrating the Base SDK using sequence diagrams and code examples.
1. Launcher execution verification and Base SDK initialization
If the game is an official release version, first verify that the game was launched from the launcher, then immediately initialize the Base SDK. Verification and initialization are bundled into a single call flow.
This is a mandatory function that must be executed.
ㆍ If you do not call Base_RestartAppIfNecessaryAsync, you will not receive the essential information (service settings, authentication context, etc.) required to run the game from the launcher, and subsequent SDK APIs will not function properly.
ㆍ The initialization parameters passed during the call are cached within the SDK and become the input values for Base_InitializeEx, so please ensure verification and initialization are connected in a single flow.
- Call Condition
- In the official release version, you must verify that the game was launched via the launcher for it to run normally.
- Base SDK initialization must take precedence over other PC SDK module initializations.
- Both APIs must be called from the UI Thread.
- Must be called after the game starts and before using other Base SDK features.
- Should only run once when the game is executed. Do not repeat
Init/UnInitduring execution.
- Operating Principle
- Launcher Verification:
Base_RestartAppIfNecessaryAsyncprocesses verification asynchronously. The result is passed to therestartAppIfNecessaryargument of the callback.- If
restartAppIfNecessaryistrue, it means the game was relaunched via the launcher, so the current game instance should be terminated. - The timeout (in milliseconds) to wait for the launcher response is passed to the
Base_RestartAppIfNecessaryAsyncargument ofwaitTimeMillisec. Generally, 60,000 (60 seconds) is used.
- If
- Parameter Cache: The
initParampassed during the verification call is cached within the SDK. - Base SDK Initialization: Call
restartAppIfNecessary == falsein theBase_InitializeExbranch of the verification callback to initialize with the cached parameters. There is no need to pass separate parameters again.- If using other modules such as View or IAP, call the initialization function for each module (e.g.,
View_Initialize,IAP_Initialize) separately after Base SDK initialization. Other modules like PCBang also follow their own initialization flows.
- If using other modules such as View or IAP, call the initialization function for each module (e.g.,
- Launcher Verification:
Be careful with the lifespan of the initParam referenced in the callback.
ㆍ The initParam must be alive at the time the asynchronous callback is called. For Native/Unreal, declare it as a static or member variable; for Unity, declare it as a class member variable.
Base_InitializeEx will fail if there are no pre-cached parameters.
ㆍ Base_InitializeEx must be used only after calling Base_RestartAppIfNecessaryAsync first.
- Sequence Diagram
- Code Example
Functions in the example that do not start with Base_ are virtual functions not provided by the SDK.
GameLoop() · ProcessGameLogic() · Render() Functions corresponding to the game loop, such as , are named only for the purpose of explaining the example. The actual implementation must be written by the developer to suit the game. Functions provided by PCSDK3 start with a module prefix (Base_ · IAP_ · View_ etc.).
#include "BaseSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
void Base_RestartAppIfNecessaryAsync_Example()
{
// 콜백에서 참조하므로 static으로 선언
static StovePCInitializeParam initParam;
initParam.SetEnvironment(L"YOUR_ENV(ex.SANDBOX)");
initParam.SetGameID(L"YOUR_GAME_ID");
initParam.SetApplicationKey(L"YOUR_APP_KEY");
// Base_RestartAppIfNecessaryAsync 호출 (타임아웃 60초)
Base_RestartAppIfNecessaryAsync(&initParam, 60'000, [](
CallbackResult callbackResult, bool restartAppIfNecessary)
{
if (restartAppIfNecessary)
{
// 런처를 통해 재실행되었으므로 현재 인스턴스는 종료
return;
}
// 검증 통과 → 캐시된 파라미터로 Base SDK 초기화 (Base_InitializeEx)
Base_InitializeEx([](CallbackResult initResult)
{
if (initResult.GetResult().IsSuccessful())
{
// Base SDK 초기화 성공 시 로직을 구현해 주세요.
// ex) 이곳에서 다른 SDK 모듈의 Initialize를 진행할 수 있어요.
}
else
{
// Base SDK 초기화 실패 시 로직을 구현해 주세요.
}
});
});
}
2. Execute API Callbacks
This step executes callbacks registered to the PC SDK's asynchronous APIs. Registered callbacks are added to a callback queue and are executed all at once when this API is called.
- Callbacks registered to PC SDK modules other than the Base SDK (
View,IAP,PCBang, etc.) are also executed here. - If not called periodically in the game's main loop, some PC SDK APIs may not function correctly.
- This API must be called from the UI Thread.
- Comparison of the two options
| API | Operation | When to use |
|---|---|---|
| Base_RunCallback() | Executes all callbacks in the queue at once | General game loops where callback processing time does not significantly impact the frame rate |
| Base_RunCallbackWithTimeout(ms) | Executes only up to the specified timeout (in milliseconds) and processes the rest in the next call | Frame-sensitive games like action or MMO games where callback execution time could cause frame drops |
Callback Execution Thread Guide
ㆍ All SDK callbacks are executed on the calling thread at the time of Base_RunCallback() / Base_RunCallbackWithTimeout() call.
ㆍ If called from the game's main loop, callbacks are safely executed on the main thread.
Caution when using variables in callbacks
ㆍ If you capture local variables by reference (&) in an asynchronous API callback (lambda), the variables may have already been destroyed by the time the callback is executed.
ㆍ Please declare variables used in callbacks as [&] or as class member variables.
static or as class member variables.
- Sequence Diagram
- Code Example
#include "BaseSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
void GameLoop()
{
while (gameRunning)
{
ProcessGameLogic();
// 옵션 A: 큐에 쌓인 모든 콜백 한 번에 실행
Base_RunCallback();
// 옵션 B: 콜백 실행 시간을 최대 10ms로 제한
// 시간을 초과하면 남은 콜백은 다음 호출 시 이어서 실행
// Base_RunCallbackWithTimeout(10);
Render();
}
}
3. Access Token Retrieval and Renewal Notification Registration
The Access token used for STOVE platform authentication is automatically renewed within the PCSDK 10 minutes before expiration. In game code, you can handle tokens using two APIs.
- Comparison of the two APIs
| API | Purpose | When to use |
|---|---|---|
| Base_GetAccessToken | Currently valid Access token immediate retrieval | Call whenever you need to pass the token externally, such as for game server authentication or calling STOVE REST APIs. It always returns the latest value. |
| Base_AccessTokenRenewed | At the moment of automatic renewal register notification callback | Register a callback when post-processing is required, such as synchronizing with the game server or invalidating caches immediately after the token is automatically renewed within the SDK. You only need to register it once during game execution. |
Do not cache tokens in game variables.
ㆍ Since tokens are automatically renewed 10 minutes before expiration, you must always retrieve and use the latest value using Base_GetAccessToken whenever an external call is required.
ㆍ No API is provided to force a renewal. If post-processing is required after renewal, register a callback using Base_AccessTokenRenewed.
Base_AccessTokenRenewed should be called only once.
ㆍ Since this API is for callback registration, you only need to call it once during game execution.
ㆍ The best place to call it is immediately after Base_InitializeEx succeeds, when other PCSDK initialization is complete.
- Sequence Diagram
- Code Example
#include "BaseSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
// (1) 갱신 알림 콜백 등록 - 초기화 직후 1회 호출
void Base_AccessTokenRenewed_Example()
{
Base_AccessTokenRenewed(
[](CallbackResult callbackResult, StovePCToken token)
{
if(callbackResult.GetResult().IsSuccessful())
{
// Access token 자동 갱신 후 후속 처리를 구현해 주세요.
const wchar_t* renewed = token.GetAccessToken();
}
else
{
// 갱신 실패 시 로직을 구현해 주세요.
}
}
);
}
// (2) 현재 Access token 즉시 조회 - 외부 호출 직전마다 호출
void Base_GetAccessToken_Example()
{
// 토큰을 받을 버퍼를 충분한 크기로 준비해 주세요.
wchar_t accessToken[4096] = { 0 };
auto result = Base_GetAccessToken(accessToken, 4096);
if(result.IsSuccessful())
{
// accessToken 버퍼에 항상 최신 토큰이 채워져요. 외부 서버 호출 등에 사용해 주세요.
}
else
{
// 조회 실패 시 로직을 구현해 주세요.
}
}
4. Retrieving User, Country, and Authentication Information
Information about the user currently logged in via the Stove Launcher is provided through three separate APIs. Choose the appropriate API for your needs, such as for game screens, policy branching, or determining payment eligibility.
| API | Return Structure | Target |
|---|---|---|
| Base_GetUser | StovePCUser | Basic Stove user information (nickname, game user ID) |
| Base_GetGds | StovePCGds | Connected country, regulations, time zone, and language (Geo-based Distribution Service) |
| Base_GetSignin | StovePCSignin | Login authentication information (identity verification, email verification, registration country, IDP) |
All three APIs can be called after the Base SDK initialization is complete.
ㆍ You can call them freely whenever user context is needed. Since the return values are cached by the SDK, the call cost is low.
4-1. Base_GetUser — Basic User Information
StovePCUser provides the following information:
| Field | Type | Description |
|---|---|---|
| nickname | string | The Stove nickname of the user logged in via the Stove Launcher. Use this for in-game UI display names, chat, customer inquiries, etc. |
| gameUserId | uint64 | The game user identifier issued by the Stove platform. Use this as a key value for identifying Stove accounts on your game server, or for payments and log tracking. |
4-2. Base_GetGds — Connected Country, Regulations, and Locale
GDS (Geo-based Distribution Service) is information about country, regulation, and locale based on the user's connection IP. It is used for regional policy branching such as Vietnam regulations, shutdown, and terms of service display language.Regional policy branchingis used for.
StovePCGdsInformation provided by :
| Field | Type | Description |
|---|---|---|
| isDefault | bool | Returns the STOVE default value if the country code cannot be identified by IP, which is true. Returns false if identified by IP. |
| nation | string | Connection country code (ISO 3166-1 alpha-2). E.g., KR, VN, US. |
| regulation | string | The regulation name applied to the connection country code. (e.g., Vietnam age rating display / Korea shutdown policy, etc.) |
| timeZone | string | Connection time zone information. Used for displaying maintenance/event times, etc. |
| utcOffset | int | UTC offset of the connection time zone (in minutes). |
| language | string | Connection language code. |
4-3. Base_GetSignin — Login Authentication Information
Queries the STOVE platform authentication context where the game is currently running. You can check whether identity verification or email verification has been completed, the country of registration, and the IDP (Identity Provider) used.
StovePCSigninInformation provided by :
| Field | Type | Description |
|---|---|---|
| personVerify | bool | Whether identity verification has been completed. |
| emailVerify | bool | Whether email verification has been completed. |
| nationality | string | STOVE platform registration country code (ISO 3166-1 alpha-2). |
| providerCode | string | IDP classification code used for STOVE login. Use this field on PC.SO STOVE Email / FB Facebook / NAVER Naver / GP Google / APPLE Apple / LINE LINE / STEAM Steam / QR QR Login / RT PC client-based auto-login, etc. |
Please use providerCode on PC.
ㆍ accountType defined together in the Signin information is a mobile legacy specification and is not used on PC.
- Sequence Diagram
- Code Example
#include "BaseSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
// (1) 사용자 기본 정보 조회
void Base_GetUser_Example()
{
StovePCUser user;
auto result = Base_GetUser(&user);
if(result.IsSuccessful())
{
const wchar_t* nickname = user.GetNickname();
uint64_t gameUserId = user.GetGameUserId();
}
}
// (2) 접속 국가·규제·로케일 조회
void Base_GetGds_Example()
{
StovePCGds gds;
auto result = Base_GetGds(&gds);
if(result.IsSuccessful())
{
const wchar_t* nation = gds.GetNation();
bool isDefault = gds.IsDefault();
const wchar_t* regulation = gds.GetRegulation();
const wchar_t* language = gds.GetLanguage();
const wchar_t* timeZone = gds.GetTimeZone();
}
}
// (3) 로그인 인증 정보 조회
void Base_GetSignin_Example()
{
StovePCSignin signin;
auto result = Base_GetSignin(&signin);
if(result.IsSuccessful())
{
const wchar_t* providerCode = signin.GetProviderCode();
bool personVerify = signin.GetPersonVerify();
bool emailVerify = signin.GetEmailVerify();
const wchar_t* nationality = signin.GetNationality();
}
}
5. Character/World Settings
Base_SetGameProfile Register the World Identifier (worldId) and Character Identifier (characterNumber) currently connected to the game with the PC SDK via the API. The registered identifiers are used as key values for payment and operation functions to distinguish user context.
| Field | Type | Description |
|---|---|---|
| worldId | string | The identifier of the world (server) the user is connected to. For games that do not support worlds, register one default world in Partners and use that identifier. |
| characterNumber | long | The identifier of the character selected by the user. Please update this whenever the character is changed or the user reconnects to a different world. |
This is directly linked to billing (payment) processing.
ㆍ STOVE In-App Purchase (IAP) processes receipts, item delivery, and refunds based on the worldId + characterNumber at the time of payment.
ㆍ If you call functions such as IAP_StartPurchase while the character/world is not set, payments may fail, or even if successful, the recipient may be identified incorrectly.
ㆍ If you are using user context-based modules such as payments or coupons, please be sure to call this right before entering the main screen (at the point when character selection is complete).
- Calling conditions and precautions
- If you do not set the character/world, some PC SDK modules such as IAP and coupons may not function properly.
- Since the SDK does not separately validate input values, please check for
nulland empty strings on the game side before calling. - The entered character/world information is valid for the duration of the PC SDK lifecycle.
Base_UnInitializeIf you re-initialize afterBase_SetGameProfile, you must call it again. - If the context changes due to a user changing characters or moving worlds, please re-call it immediately to update the identifier.
- Sequence Diagram
- Code Example
#include "BaseSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
// 함수 네이밍은 예시이므로 게임 구현에 맞게 변경하세요.
void Base_SetGameProfile_Example()
{
// StovePCGameProfile 구조체 생성
// 구조체 필드에 적절한 worldId, characterNumber 값을 할당하세요.
auto gameProfile = StovePCGameProfile(L"YOUR_WORLD_ID", 0L);
// 생성한 구조체를 이용해 Base_SetGameProfile 호출
auto result = Base_SetGameProfile(&gameProfile);
if(result.IsSuccessful())
{
// 캐릭터·월드 설정 성공 시 로직을 구현해 주세요.
}
else
{
// 캐릭터·월드 설정 실패 시 로직을 구현해 주세요.
}
}
6. Base SDK Cleanup
Base_UnInitialize Call the API to clean up the Base SDK and return resources in use. You must perform the Base SDK cleanup logic before the game terminates.
- Calling conditions
- Base SDK cleanup must be performed last, after other PC SDK cleanups. If you clean up the Base SDK before other PC SDKs, the cleanup may not be performed correctly.
- You cannot use Base SDK features after cleaning up the Base SDK.
- Base SDK cleanup must be called on the UI Thread.
- It should only run once when the game terminates.
- Sequence Diagram
- Code Example
#include "BaseSDK.h"
using namespace Stove::PCSDK;
using namespace Stove::PCSDK::Base;
void Base_UnInitialize_Example()
{
// 다른 SDK를 사용했다면 Base_UnInitialize()가 마지막으로 호출되어야 해요.
// ex) 정리 순서
// PCBang_UserLogOut();
// PCBang_UnInitialize();
// View_UnInitialize();
// IAP_UnInitialize();
// Base_UnInitialize();
auto result = Base_UnInitialize();
if(result.IsSuccessful())
{
// Base SDK 정리 성공 시 로직을 구현해 주세요.
}
else
{
// Base SDK 정리 실패 시 로직을 구현해 주세요.
}
}
- Developers Center Usage / Smilegate Publishing Games: stove.developers@smilegate.com
- STOVE Store Onboarding / STOVE Studio: store.support@smilegate.com