シーズンパスをゲームに統合する

Last updated on February 4, 2026

注釈：本資料はAI技術を用いて翻訳されています。

概要

この記事では、Client SDKまたはExtend SDKを通じて、AccelByte Gaming Services (AGS) シーズンパスサービスをゲームに統合する方法を説明します:

ゲームクライアントから現在のシーズンパス情報を取得する
ゲームクライアントからユーザーのシーズン進行状況を取得する
ゲームクライアントからXPを付与してティアをレベルアップする
ゲームクライアントからシーズンパスの報酬を獲得する

前提条件

次へのアクセスが必要です:

AGS Admin Portal
- AccelByte Unreal SDK、AccelByte Unity SDK、またはAccelByte Extend SDK(必要な権限を含む):
  - クライアントID
  - クライアントシークレット
さらなる参照のためのAccelByte シーズンパス API ドキュメント

また、シーズンパスをゲームに統合するために、Admin Portal経由でシーズンパスを設定していることを確認する必要があります。

現在のシーズンパスを取得する

ゲームクライアントは、現在アクティブなシーズンパスをクエリして、必要なXPや各ティアの報酬パスを含むティア進行情報などの情報を返すことができます。

FString Language = TEXT("en");

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto SeasonPassApi = ApiClient->GetSeasonPassApi().Pin();
SeasonPassApi->GetCurrentSeason(
     Language,
     THandler<FAccelByteModelsSeasonInfo>::CreateLambda([&](const FAccelByteModelsSeasonInfo& Result)
    {
        // Do something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

string language = "en";

seasonPass.GetCurrentSeason(language, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

var response = sdk.Seasonpass.Season.PublicGetCurrentSeasonOp
    .SetLanguage("en")
    .Execute(sdk.Namespace);
if (response != null)
{
    //do something when success
}

seasonService := &seasonpass.SeasonService{
	Client:          factory.NewSeasonpassClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
language := "en"
input := &season.PublicGetCurrentSeasonParams{
	Namespace: namespace,
	Language:  &language,
}
result, err := seasonService.PublicGetCurrentSeasonShort(input)

final Season seasonWrapper = new Season(sdk);
String language = "en";

LocalizedSeasonInfo localizedSeasonInfo;
try {
	localizedSeasonInfo = seasonWrapper.publicGetCurrentSeason(PublicGetCurrentSeason.builder()
		.namespace("<namespace>")
		.language(language)
		.build());
} catch (HttpResponseException e) {
	// Do something when failed
	return;
}

if (localizedSeasonInfo != null)
{
	// Do something when successful
}

import accelbyte_py_sdk.api.seasonpass as seasonpass_service

result, error = group_service.public_get_current_season(
    language="en",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

プレイヤーの現在のシーズンパス進行状況を取得する

ゲームクライアントは、プレイヤーのシーズンデータをクエリして、プレイヤーにシーズンの進行状況と獲得可能な報酬を表示できます。

FString Language = TEXT("en");

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto SeasonPassApi = ApiClient->GetSeasonPassApi().Pin();
SeasonPassApi->GetCurrentUserSeason(
   THandler<FAccelByteModelsUserSeasonInfo>::CreateLambda([](const FAccelByteModelsUserSeasonInfo& Result)
    {
        // Do something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

seasonPass.GetCurrentUserSeason(result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

string userId = "<user-id>";

var response = sdk.Seasonpass.Season.PublicGetCurrentUserSeasonOp
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

seasonService := &seasonpass.SeasonService{
	Client:          factory.NewSeasonpassClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
input := &season.PublicGetCurrentUserSeasonParams{
	Namespace: namespace,
	UserID:    userId,
}
result, err := seasonService.PublicGetCurrentUserSeasonShort(input)

final Season seasonWrapper = new Season(sdk);
String userId = "YourUserId";
final ClaimableUserSeasonInfo response;
try {
    response = seasonWrapper.publicGetCurrentUserSeason(PublicGetCurrentUserSeason.builder()
        .namespace("<namespace>")
        .userId(userId)
        .build());
} catch (Exception e) {
    // Do something when failed
    return;
}

if (response == null) {
    // Null response from server
} else {
    // Do something when successful
}

import accelbyte_py_sdk.api.seasonpass as seasonpass_service

result, error = group_service.public_get_current_user_season(
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

Server APIを使用してプレイヤーにXPを付与する

ゲームサーバーは、Server APIを使用してプレイヤーに経験値(XP)を付与し、プレイヤーがシーズンを進行するのを支援できます。たとえば、プレイヤーがシーズン中にタスクやチャレンジを完了すると、XPを付与できます。

int32 EXP = 300;
FString UserId = "TargetUserId";

auto ServerApiClient = AccelByteOnlineSubsystemPtr->GetServerApiClient();
ServerApiClient->ServerSeasonPass.GrantExpToUser(
    UserId, EXP,
    THandler<FAccelByteModelsUserSeasonInfoWithoutReward>::CreateLambda(
    [](const FAccelByteModelsUserSeasonInfoWithoutReward& Result)
    {
        // Do something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

int exp = 300;
string userId = "TargetUserId";

seasonPass.GrantExpToUser(userId, exp, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

string userId = "<user-id>";

var response = sdk.Seasonpass.Tier.GrantUserExpOp
    .SetBody(new UserExpGrant()
    {
        Exp = 300
    })
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

tierService := &seasonpass.TierService{
	Client:          factory.NewSeasonpassClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
body := seasonpassclientmodels.UserExpGrant {
	Exp: 300,
}
input := &tier.GrantUserExpParams{
	Body:      &body,
	Namespace: namespace,
	UserID:    userId,
}
result, err := tierService.GrantUserExpShort(input)

Tier tierWrapper = new Tier(sdk);

String userId = "<user-id>";
UserSeasonSummary response;
try {
	UserExpGrant reqBody = UserExpGrant.builder()
		.exp(300)
		.build();
	response = tierWrapper.grantUserExp(GrantUserExp.builder()
			.namespace("<namespace>")
			.userId(userId)
			.body(reqBody)
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.seasonpass as seasonpass_service
import accelbyte_py_sdk.api.seasonpass.models as seasonpass_models

result, error = group_service.grant_user_exp(
    user_id="********************************",
    body=seasonpass_models.UserExpGrant()
        .with_exp(300),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

ティアでレベルアップする

プレイヤーは2つの方法でティアを上げることができます: シーズンチャレンジでXPを獲得するか、ティアへのアクセスを購入するかです。プレイヤーがXPを獲得してティアを上げた場合、ティアは自動的にレベルアップし、XPは0にリセットされ、前のティアから残ったXPはプレイヤーのXPに追加されます。プレイヤーは、上位ティアへのアクセスを購入することもできます。

ティアアクセスを購入する前に、ティアアイテムの詳細情報を持っていることを確認してください。それ以外の場合は、Ecommerceサービスからティアアイテムをクエリして、アイテムの詳細を取得する必要があります。

FAccelByteModelsItemCriteria ItemCriteria;
ItemCriteria.ItemType = EAccelByteItemType::SEASON;
ItemCriteria.CategoryPath = TEXT("/seasonpass");
int32 Offset = 0;
int32 Limit = 32;

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto ItemApi = ApiClient->GetItemApi().Pin();
ItemApi->GetItemsByCriteria(
 	ItemCriteria, Offset, Limit,
 	THandler<FAccelByteModelsItemPagingSlicedResult>::CreateLambda([](const FAccelByteModelsItemPagingSlicedResult& Result)
	{
    	// Do something when successful
	}),
	FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
	{
    	// Do something when failed
	})
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

ItemCriteria itemCriteria = new ItemCriteria
{
	language = "en",
	region = "US",
	itemType = ItemType.SEASON,
	categoryPath = "/seasonpass",
};

seasonPass.GetItemsByCriteria(itemCriteria, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

var response = sdk.Platform.Item.QueryItems1Op
    .SetRegion("US")
    .SetItemType(QueryItems1ItemType.SEASON)
    .SetCategoryPath("/seasonpass")
    .Execute(sdk.Namespace);
if (response != null)
{
    //do something when success
}

itemService := &platform.ItemService{
	Client:          factory.NewPlatformClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
categoryPath := "/seasonpass"
itemType := item.QueryItems1SEASONConstant
region := "US"
input := &item.QueryItems1Params{
	Namespace:              namespace,
	CategoryPath:           &categoryPath,
	ItemType:               &itemType,
	Region:                 &region,
}
result, err := itemService.QueryItems1Short(input)

Item itemWrapper = new Item(sdk);

FullItemPagingSlicedResult response;
try {
	response = itemWrapper.queryItems(QueryItems.builder()
			.namespace("<namespace>")
			.region("US")
			.itemType("SEASON")
            .categoryPath("/seasonpass")
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.platform as platform_service

result, error = platform_service.query_items_1(
    region="US",
    item_type="SEASON",
    category_path="/seasonpass",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

ティアアイテム情報を取得した後、ゲームクライアントはCreateNewOrder関数を呼び出してティアへのアクセスを購入できます。

FAccelByteModelsOrderCreate OrderTier;
OrderTier.CurrencyCode = TEXT("CurrencyCode");
OrderTier.DiscountedPrice = 100;
OrderTier.Price = 100;
OrderTier.Quantity = 1;
OrderTier.ReturnUrl = TEXT("https://example.com");
OrderTier.ItemId = TEXT("ItemId");
OrderTier.Region = "US";
OrderTier.Language = "en";

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto OrderApi = ApiClient->GetOrderApi().Pin();
OrderApi->CreateNewOrder(
    OrderTier,
    THandler<FAccelByteModelsOrderInfo>::CreateLambda([&](const FAccelByteModelsOrderInfo& Result)
    {
        // So something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

OrderRequest orderTier = new OrderRequest
{
	currencyCode = "CurrencyCode",
	discountedPrice = 100,
	itemId = "ItemId",
	price = 100,
	quantity = 1,
	returnUrl = "https://example.com",
	region = "US",
	language = "en"
};

seasonPass.CreateOrder(orderTier, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

string userId = "<user-id>";

var response = sdk.Platform.Order.PublicCreateUserOrderOp
    .SetBody(new OrderCreate()
    {
        CurrencyCode = "CurrencyCode",
        DiscountedPrice = 100,
        ItemId = "<item-id>",
        Price = 100,
        Quantity = 1,
        ReturnUrl = "https://example.com",
        Region = "US",
        Language = "en"
    })
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

orderService := &platform.OrderService{
	Client:          factory.NewPlatformClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
currencyCode := "mycurrencycode"
discountedPrice := int32(100)
itemId := "myitemid"
quantity := int32(1)
body := platformclientmodels.OrderCreate {
	CurrencyCode: &currencyCode,
	DiscountedPrice: &discountedPrice,
	ItemID: &itemId,
	Price: 100,
	Quantity: &quantity,
	ReturnURL: "https://example.com",
	Region: "US",
	Language: "en",
}
input := &order.PublicCreateUserOrderParams{
	Body:      &body,
	Namespace: namespace,
	UserID:    userId,
}
result, err := orderService.PublicCreateUserOrderShort(input)

Order orderWrapper = new Order(sdk);

String userId = "<user-id>";
OrderInfo response;
try {
	OrderCreate reqBody = OrderCreate.builder()
        .currencyCode("CurrencyCode")
        .discountedPrice(100)
        .itemId("<item-id>")
        .price(100)
        .quantity(1)
        .returnUrl("https://example.com")
        .region("US")
        .language("en")
		.build();
	response = orderWrapper.publicCreateUserOrder(PublicCreateUserOrder.builder()
			.namespace("<namespace>")
			.userId(userId)
			.body(reqBody)
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.platform as platform_service
import accelbyte_py_sdk.api.platform.models as platform_models

result, error = platform_service.public_create_user_order(
    user_id="********************************",
    body=platform_models.OrderCreate()
        .with_currency_code("CurrencyCode")
        .with_discounted_price(100)
        .with_item_id("ItemId")
        .with_price(100)
        .with_quantity(1)
        .with_return_url("https://example.com")
        .with_region("US")
        .with_language("en"),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

プレミアムパスをアンロックする

プレイヤーは、プレミアムパスを購入して、シーズンイベントから追加の報酬へのアクセスを獲得できます。プレミアムパスアイテムを購入する前に、その詳細情報を持っていることを確認してください。それ以外の場合は、プレミアムパスアイテムをクエリして、アイテムの詳細を取得する必要があります。

FAccelByteModelsItemCriteria ItemCriteria;
ItemCriteria.ItemType = EAccelByteItemType::SEASON;
ItemCriteria.CategoryPath = TEXT("/seasonpass");
int32 Offset = 0;
int32 Limit = 32;

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto ItemApi = ApiClient->GetItemApi().Pin();
ItemApi->GetItemsByCriteria(
	ItemCriteria, Offset, Limit, THandler<FAccelByteModelsItemPagingSlicedResult>::CreateLambda(
	[](const FAccelByteModelsItemPagingSlicedResult& Result)
	{
    	// Do something when successful
	}),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
	{
    	// Do something when failed
	})
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

ItemCriteria itemCriteria = new ItemCriteria
{
	language = "en",
	region = "US",
	itemType = ItemType.SEASON,
	categoryPath = "/seasonpass",
};

seasonPass.GetItemsByCriteria(itemCriteria, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

var response = sdk.Platform.Item.QueryItems1Op
    .SetRegion("US")
    .SetItemType(QueryItems1ItemType.SEASON)
    .SetCategoryPath("/seasonpass")
    .Execute(sdk.Namespace);
if (response != null)
{
    //do something when success
}

itemService := &platform.ItemService{
	Client:          factory.NewPlatformClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
categoryPath := "/seasonpass"
itemType := item.QueryItems1SEASONConstant
region := "US"
input := &item.QueryItems1Params{
	Namespace:              namespace,
	CategoryPath:           &categoryPath,
	ItemType:               &itemType,
	Region:                 &region,
}
result, err := itemService.QueryItems1Short(input)

Item itemWrapper = new Item(sdk);

FullItemPagingSlicedResult response;
try {
	response = itemWrapper.queryItems(QueryItems.builder()
			.namespace("<namespace>")
			.region("US")
			.itemType("SEASON")
            .categoryPath("/seasonpass")
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.platform as platform_service

result, error = platform_service.query_items_1(
    region="US",
    item_type="SEASON",
    category_path="/seasonpass",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

プレミアムパスアイテム情報を取得した後、ゲームクライアントはCreateNewOrder関数を呼び出してプレミアムパスを購入できます。

FAccelByteModelsOrderCreate OrderPass;
OrderTier.CurrencyCode = TEXT("CurrencyCode");
OrderTier.DiscountedPrice = 100;
OrderTier.Price = 100;
OrderTier.Quantity = 1;
OrderTier.ReturnUrl = TEXT("https://example.com");
OrderTier.ItemId = TEXT("ItemId");
OrderTier.Region = "US";
OrderTier.Language = "en";

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto OrderApi = ApiClient->GetOrderApi().Pin();
OrderApi->CreateNewOrder(
    OrderPass,
    THandler<FAccelByteModelsOrderInfo>::CreateLambda([&](const FAccelByteModelsOrderInfo& Result)
    {
        // Do something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

OrderRequest orderPass = new OrderRequest
{
	currencyCode = "CurrencyCode",
	discountedPrice = 100,
	itemId = "ItemId",
	price = 100,
	quantity = 1,
	returnUrl = "https://example.com",
	region = "US",
	language = "en"
};

seasonPass.CreateOrder(orderPass, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

string userId = "<user-id>";

var response = sdk.Platform.Order.PublicCreateUserOrderOp
    .SetBody(new OrderCreate()
    {
        CurrencyCode = "CurrencyCode",
        DiscountedPrice = 100,
        ItemId = "<item-id>",
        Price = 100,
        Quantity = 1,
        ReturnUrl = "https://example.com",
        Region = "US",
        Language = "en"
    })
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

orderService := &platform.OrderService{
	Client:          factory.NewPlatformClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
currencyCode := "mycurrencycode"
discountedPrice := int32(100)
itemId := "myitemid"
quantity := int32(1)
body := platformclientmodels.OrderCreate {
	CurrencyCode: &currencyCode,
	DiscountedPrice: &discountedPrice,
	ItemID: &itemId,
	Price: 100,
	Quantity: &quantity,
	ReturnURL: "https://example.com",
	Region: "US",
	Language: "en",
}
input := &order.PublicCreateUserOrderParams{
	Body:      &body,
	Namespace: namespace,
	UserID:    userId,
}

Order orderWrapper = new Order(sdk);

String userId = "<user-id>";
OrderInfo response;
try {
	OrderCreate reqBody = OrderCreate.builder()
        .currencyCode("CurrencyCode")
        .discountedPrice(100)
        .itemId("<item-id>")
        .price(100)
        .quantity(1)
        .returnUrl("https://example.com")
        .region("US")
        .language("en")
		.build();
	response = orderWrapper.publicCreateUserOrder(PublicCreateUserOrder.builder()
			.namespace("<namespace>")
			.userId(userId)
			.body(reqBody)
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.platform as platform_service
import accelbyte_py_sdk.api.platform.models as platform_models

result, error = platform_service.public_create_user_order(
    user_id="********************************",
    body=platform_models.OrderCreate()
        .with_currency_code("CurrencyCode")
        .with_discounted_price(100)
        .with_item_id("ItemId")
        .with_price(100)
        .with_quantity(1)
        .with_return_url("https://example.com")
        .with_region("US")
        .with_language("en"),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

報酬を獲得する

シーズンがプレイヤーの獲得した報酬を自動的に付与するように設定されていない場合、ゲームクライアントはプレイヤーの報酬を手動で獲得する必要があります。ClaimRewards関数を使用して、プレイヤーの報酬を獲得できます。

FString PassCode = TEXT("PremiumPassCode");
int32 TierIndex = 0;
FString RewardCode = TEXT("RewardCode");

FAccelByteModelsSeasonClaimRewardRequest ClaimRequest{
   PassCode, TierIndex, RewardCode
};
auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto SeasonPassApi = ApiClient->GetSeasonPassApi().Pin();
SeasonPassApi->ClaimRewards(
     ClaimRequest,
     THandler<FAccelByteModelsSeasonClaimRewardResponse>::CreateLambda(
     [&](const FAccelByteModelsSeasonClaimRewardResponse& Result)
    {
        // Do something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

SeasonClaimRewardRequest claimRewardRequest = new SeasonClaimRewardRequest
{
	passCode = "PremiumPassCode",
	tierIndex = 0,
	rewardCode = "RewardCode",
};

seasonPass.ClaimRewards(claimRewardRequest, result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}");
		return;
	}
	
	// Do something when successful
});

string userId = "<user-id>";

var response = sdk.Seasonpass.Reward.PublicClaimUserRewardOp
    .SetBody(new UserRewardClaim()
    {
        PassCode = "PremiumPassCode",
        TierIndex = 0,
        RewardCode = "RewardCode"
    })
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

rewardService := &seasonpass.RewardService{
	Client:          factory.NewSeasonpassClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
passCode := "PremiumPassCode"
tierIndex := int32(0)
rewardCode := "RewardCode"
body := seasonpassclientmodels.UserRewardClaim {
	PassCode: &passCode,
	TierIndex: &tierIndex,
	RewardCode: &rewardCode,
}
input := &reward.PublicClaimUserRewardParams{
	Body:      &body,
	Namespace: namespace,
	UserID:    userId,
}
result, err := rewardService.PublicClaimUserRewardShort(input)

Reward rewardWrapper = new Reward(sdk);

String userId = "<user-id>";
ClaimableRewards response;
try {
	UserRewardClaim reqBody = UserRewardClaim.builder()
        .passCode("PremiumPassCode")
        .tierIndex(0)
        .rewardCode("RewardCode")
		.build();
	response = rewardWrapper.publicClaimUserRewards(PublicClaimUserReward.builder()
			.namespace("<namespace>")
            .userId(userId)
			.body(reqBody)
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.platform as platform_service
import accelbyte_py_sdk.api.platform.models as platform_models

result, error = platform_service.public_claim_user_reward(
    user_id="********************************",
    body=platform_models.UserRewardClaim()
        .with_pass_code("PremiumPassCode")
        .with_reward_code("RewardCode")
        .with_tier_index(0),
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

すべての報酬を獲得する

プレイヤーが獲得可能な複数の報酬を持っている場合、ゲームクライアントはすべての報酬を一度に獲得できます。BulkClaimRewardsを使用して、複数の報酬を同時に獲得できます。

auto ApiClient = AccelByteOnlineSubsystemPtr->GetApiClient();
auto SeasonPassApi = ApiClient->GetSeasonPassApi().Pin();
SeasonPassApi->BulkClaimRewards(
     THandler<FAccelByteModelsSeasonClaimRewardResponse>::CreateLambda(
     [&](const FAccelByteModelsSeasonClaimRewardResponse& Result)
    {
        // Do something when successful
    }),
    FErrorHandler::CreateLambda([](int32 ErrorCode, FString ErrorMessage)
    {
        // Do something when failed
    })
);

var seasonPass = AccelByteSDK.GetClientRegistry().GetApi().GetSeasonPass();

seasonPass.BulkClaimRewards(result =>
{
	if (result.IsError)
	{
    	// Do something when failed
		Debug.Log($"Error {result.Error.Code}: {result.Error.Message}")
		return;
	}
	
	// Do something when successful
});

string userId = "<user-id>";

var response = sdk.Seasonpass.Reward.PublicBulkClaimUserRewardsOp
    .Execute(sdk.Namespace, userId);
if (response != null)
{
    //do something when success
}

rewardService := &seasonpass.RewardService{
	Client:          factory.NewSeasonpassClient(&repository.ConfigRepositoryImpl{}),
	TokenRepository: &repository.TokenRepositoryImpl{},
}
namespace := "mygame"
userId := "myuserid"
input := &reward.PublicBulkClaimUserRewardsParams{
	Namespace: namespace,
	UserID:    userId,
}
result, err := rewardService.PublicBulkClaimUserRewardsShort(input)

Reward rewardWrapper = new Reward(sdk);

String userId = "<user-id>";
ClaimableRewards response;
try {
	response = rewardWrapper.publicBulkClaimUserRewards(PublicBulkClaimUserRewards.builder()
			.namespace("<namespace>")
			.userId(userId)
			.build());
} catch (Exception e) {
	// Do something when failed
	return;
}

if (response == null) {
	// Null response from server
} else {
	// Do something when successful
}

import accelbyte_py_sdk.api.platform as platform_service

result, error = platform_service.public_bulk_claim_user_rewards(
    user_id="********************************",
    namespace=namespace,  # optional, gets the value from the global instance if unspecified
    sdk=sdk,  # optional, gets the global instance  if unspecified
)
if error:
    exit(error)

概要​

前提条件​

現在のシーズンパスを取得する​

プレイヤーの現在のシーズンパス進行状況を取得する​

Server APIを使用してプレイヤーにXPを付与する​

ティアでレベルアップする​

プレミアムパスをアンロックする​

報酬を獲得する​

すべての報酬を獲得する​

概要