GS2-Ranking2 SDK for Game Engine API 레퍼런스

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: null,
        userId: "user-0001"
    );
    var future = domain.GetGlobalRankingRankFuture(
    );
    yield return future;
    if (future.Error != null)
    {
        onError.Invoke(future.Error, null);
        yield break;
    }
    var future2 = future.Result.ModelFuture();
    yield return future2;
    if (future2.Error != null)
    {
        onError.Invoke(future2.Error, null);
        yield break;
    }
    var result = future2.Result;

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        nullptr, // season
        "user-0001" // userId
    );
    const auto Future = Domain->GetGlobalRankingRank(
    );
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

    // 변경된 값 / 결과 값을 취득
    const auto Future2 = Future->GetTask().Result()->Model();
    Future2->StartSynchronousTask();
    if (Future2->GetTask().IsError())
    {
        return Future2->GetTask().Error();
    }
    const auto Result = Future2->GetTask().Result();

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    ).global_ranking_season(
        null,
        null
    ).global_ranking_data(
        null
    )

var async_result = await domain.get_global_ranking_rank(
)
if async_result.error != null:
    push_error(str(async_result.error))
    return

var result = async_result.result

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: null,
        userId: "user-0001"
    );
    var it = domain.GlobalRankings(
    );
    List<EzGlobalRankingData> items = new List<EzGlobalRankingData>();
    while (it.HasNext())
    {
        yield return it.Next();
        if (it.Error != null)
        {
            onError.Invoke(it.Error, null);
            break;
        }
        if (it.Current != null)
        {
            items.Add(it.Current);
        }
        else
        {
            break;
        }
    }

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        nullptr, // season
        "user-0001" // userId
    );
    const auto It = Domain->GlobalRankings(
    );
    TArray<Gs2::UE5::Ranking2::Model::FEzGlobalRankingDataPtr> Result;
    for (auto Item : *It)
    {
        if (Item.IsError())
        {
            return false;
        }
        Result.Add(Item.Current());
    }

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    );
    var future = domain.ModelFuture();
    yield return future;
    var item = future.Result;

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    );
    const auto Future = Domain->Model();
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    )

var async_result = await domain.model()
if async_result.error != null:
    push_error(str(async_result.error))
    return

var result = async_result.result

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    );
    
    // 이벤트 핸들링 시작
    var callbackId = domain.Subscribe(
        value => {
            // 값이 변화했을 때 호출됨
            // value에는 변경 후의 값이 전달됨
        }
    );

    // 이벤트 핸들링 정지
    domain.Unsubscribe(callbackId);

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    );
    
    // 이벤트 핸들링 시작
    const auto CallbackId = Domain->Subscribe(
        [](TSharedPtr<Gs2::Ranking2::Model::FGlobalRankingModel> value) {
            // 값이 변화했을 때 호출됨
            // value에는 변경 후의 값이 전달됨
        }
    );

    // 이벤트 핸들링 정지
    Domain->Unsubscribe(CallbackId);

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    )

# 이벤트 핸들링 시작
var callback_id = domain.subscribe_model(func(value):
    # 값이 변화했을 때 호출됨
    # value에는 변경 후의 값이 전달됩니다
    pass
)

# 이벤트 핸들링 정지
domain.unsubscribe_model(callback_id)

    var domain = gs2.Ranking2.Namespace(
        namespaceName: null
    );
    var it = domain.GlobalRankingModels(
    );
    List<EzGlobalRankingModel> items = new List<EzGlobalRankingModel>();
    while (it.HasNext())
    {
        yield return it.Next();
        if (it.Error != null)
        {
            onError.Invoke(it.Error, null);
            break;
        }
        if (it.Current != null)
        {
            items.Add(it.Current);
        }
        else
        {
            break;
        }
    }

    const auto Domain = Gs2->Ranking2->Namespace(
        nullptr // namespaceName
    );
    const auto It = Domain->GlobalRankingModels(
    );
    TArray<Gs2::UE5::Ranking2::Model::FEzGlobalRankingModelPtr> Result;
    for (auto Item : *It)
    {
        if (Item.IsError())
        {
            return false;
        }
        Result.Add(Item.Current());
    }

    var domain = gs2.Ranking2.Namespace(
        namespaceName: null
    );
    
    // 이벤트 핸들링 시작
    var callbackId = domain.SubscribeGlobalRankingModels(
        () => {
            // 리스트의 요소가 변화했을 때 호출됨
        }
    );

    // 이벤트 핸들링 정지
    domain.UnsubscribeGlobalRankingModels(callbackId);

    const auto Domain = Gs2->Ranking2->Namespace(
        nullptr // namespaceName
    );
    
    // 이벤트 핸들링 시작
    const auto CallbackId = Domain->SubscribeGlobalRankingModels(
        []() {
            // 리스트의 요소가 변화했을 때 호출됨
        }
    );

    // 이벤트 핸들링 정지
    Domain->UnsubscribeGlobalRankingModels(CallbackId);

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    ).GlobalRankingReceivedReward(
    );
    var future = domain.ModelFuture();
    yield return future;
    var item = future.Result;

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    )->GlobalRankingReceivedReward(
    );
    const auto Future = Domain->Model();
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    ).global_ranking_season(
        0,
        null
    ).global_ranking_received_reward(
    )

var async_result = await domain.model()
if async_result.error != null:
    push_error(str(async_result.error))
    return

var result = async_result.result

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    ).GlobalRankingReceivedReward(
    );
    
    // 이벤트 핸들링 시작
    var callbackId = domain.Subscribe(
        value => {
            // 값이 변화했을 때 호출됨
            // value에는 변경 후의 값이 전달됨
        }
    );

    // 이벤트 핸들링 정지
    domain.Unsubscribe(callbackId);

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    )->GlobalRankingReceivedReward(
    );
    
    // 이벤트 핸들링 시작
    const auto CallbackId = Domain->Subscribe(
        [](TSharedPtr<Gs2::Ranking2::Model::FGlobalRankingReceivedReward> value) {
            // 값이 변화했을 때 호출됨
            // value에는 변경 후의 값이 전달됨
        }
    );

    // 이벤트 핸들링 정지
    Domain->Unsubscribe(CallbackId);

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    ).global_ranking_season(
        0,
        null
    ).global_ranking_received_reward(
    )

# 이벤트 핸들링 시작
var callback_id = domain.subscribe_model(func(value):
    # 값이 변화했을 때 호출됨
    # value에는 변경 후의 값이 전달됩니다
    pass
)

# 이벤트 핸들링 정지
domain.unsubscribe_model(callback_id)

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    );
    var it = domain.GlobalRankingReceivedRewards(
    );
    List<EzGlobalRankingReceivedReward> items = new List<EzGlobalRankingReceivedReward>();
    while (it.HasNext())
    {
        yield return it.Next();
        if (it.Error != null)
        {
            onError.Invoke(it.Error, null);
            break;
        }
        if (it.Current != null)
        {
            items.Add(it.Current);
        }
        else
        {
            break;
        }
    }

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    );
    const auto It = Domain->GlobalRankingReceivedRewards(
    );
    TArray<Gs2::UE5::Ranking2::Model::FEzGlobalRankingReceivedRewardPtr> Result;
    for (auto Item : *It)
    {
        if (Item.IsError())
        {
            return false;
        }
        Result.Add(Item.Current());
    }

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    );
    
    // 이벤트 핸들링 시작
    var callbackId = domain.SubscribeGlobalRankingReceivedRewards(
        () => {
            // 리스트의 요소가 변화했을 때 호출됨
        }
    );

    // 이벤트 핸들링 정지
    domain.UnsubscribeGlobalRankingReceivedRewards(callbackId);

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    );
    
    // 이벤트 핸들링 시작
    const auto CallbackId = Domain->SubscribeGlobalRankingReceivedRewards(
        []() {
            // 리스트의 요소가 변화했을 때 호출됨
        }
    );

    // 이벤트 핸들링 정지
    Domain->UnsubscribeGlobalRankingReceivedRewards(CallbackId);

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    ).GlobalRankingReceivedReward(
    );
    var future = domain.ReceiveGlobalRankingRewardFuture(
        config: null
    );
    yield return future;
    if (future.Error != null)
    {
        if (future.Error is Gs2.Gs2Ranking2.Exception.SeasonNotEndedException)
        {
            // The ranking reward cannot be received until the season has ended.
        }
        if (future.Error is Gs2.Gs2Ranking2.Exception.RewardAlreadyReceivedException)
        {
            // The ranking reward for the specified season has already been received.
        }
        if (future.Error is Gs2.Gs2Ranking2.Exception.NoRankingRewardException)
        {
            // There is no ranking reward for the rank the player achieved.
        }
        if (future.Error is Gs2.Gs2Ranking2.Exception.SeasonNotStartedException)
        {
            // The ranking reward cannot be received for a season that has not started yet.
        }
        onError.Invoke(future.Error, null);
        yield break;
    }
    // New Experience에서는 스탬프 시트가 SDK 레벨에서 자동으로 실행됩니다.
    // 에러가 발생하면 TransactionException이 발생합니다.
    // TransactionException::Retry()로 재시도할 수 있습니다.

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    )->GlobalRankingReceivedReward(
    );
    const auto Future = Domain->ReceiveGlobalRankingReward(
        // config
    );
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        auto e = Future->GetTask().Error();
        if (e->IsChildOf(Gs2::Ranking2::Error::FSeasonNotEndedError::Class))
        {
            // The ranking reward cannot be received until the season has ended.
        }
        if (e->IsChildOf(Gs2::Ranking2::Error::FRewardAlreadyReceivedError::Class))
        {
            // The ranking reward for the specified season has already been received.
        }
        if (e->IsChildOf(Gs2::Ranking2::Error::FNoRankingRewardError::Class))
        {
            // There is no ranking reward for the rank the player achieved.
        }
        if (e->IsChildOf(Gs2::Ranking2::Error::FSeasonNotStartedError::Class))
        {
            // The ranking reward cannot be received for a season that has not started yet.
        }
        return false;
    }

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    ).global_ranking_season(
        0,
        null
    ).global_ranking_received_reward(
    )

var async_result = await domain.receive_global_ranking_reward(
    null # config
)
if async_result.error != null:
    if async_result.error is Gs2Ranking2SeasonNotEndedException:
        # 시즌이 종료될 때까지 랭킹 보상을 수령할 수 없습니다
        pass
    if async_result.error is Gs2Ranking2RewardAlreadyReceivedException:
        # 지정된 시즌의 랭킹 보상은 이미 수령했습니다
        pass
    if async_result.error is Gs2Ranking2NoRankingRewardException:
        # 플레이어의 순위에 해당하는 랭킹 보상이 없습니다
        pass
    if async_result.error is Gs2Ranking2SeasonNotStartedException:
        # 아직 시작되지 않은 시즌의 랭킹 보상은 수령할 수 없습니다
        pass
    push_error(str(async_result.error))
    return

var result = async_result.result

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    ).GlobalRankingScore(
    );
    var future = domain.ModelFuture();
    yield return future;
    var item = future.Result;

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    )->GlobalRankingScore(
    );
    const auto Future = Domain->Model();
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    ).global_ranking_season(
        0,
        null
    ).global_ranking_score(
    )

var async_result = await domain.model()
if async_result.error != null:
    push_error(str(async_result.error))
    return

var result = async_result.result

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    ).GlobalRankingScore(
    );
    
    // 이벤트 핸들링 시작
    var callbackId = domain.Subscribe(
        value => {
            // 값이 변화했을 때 호출됨
            // value에는 변경 후의 값이 전달됨
        }
    );

    // 이벤트 핸들링 정지
    domain.Unsubscribe(callbackId);

    const auto Domain = Gs2->Ranking2->Namespace(
        "namespace-0001" // namespaceName
    )->GlobalRankingModel(
        "ranking-0001" // rankingName
    )->GlobalRankingSeason(
        0, // season
        "user-0001" // userId
    )->GlobalRankingScore(
    );
    
    // 이벤트 핸들링 시작
    const auto CallbackId = Domain->Subscribe(
        [](TSharedPtr<Gs2::Ranking2::Model::FGlobalRankingScore> value) {
            // 값이 변화했을 때 호출됨
            // value에는 변경 후의 값이 전달됨
        }
    );

    // 이벤트 핸들링 정지
    Domain->Unsubscribe(CallbackId);

var domain = ez.ranking2.namespace_(
        "namespace-0001"
    ).global_ranking_model(
        "ranking-0001"
    ).global_ranking_season(
        0,
        null
    ).global_ranking_score(
    )

# 이벤트 핸들링 시작
var callback_id = domain.subscribe_model(func(value):
    # 값이 변화했을 때 호출됨
    # value에는 변경 후의 값이 전달됩니다
    pass
)

# 이벤트 핸들링 정지
domain.unsubscribe_model(callback_id)

    var domain = gs2.Ranking2.Namespace(
        namespaceName: "namespace-0001"
    ).GlobalRankingModel(
        rankingName: "ranking-0001"
    ).GlobalRankingSeason(
        season: 0,
        userId: "user-0001"
    );
    var it = domain.GlobalRankingScores(
    );
    List<EzGlobalRankingScore> items = new List<EzGlobalRankingScore>();
    while (it.HasNext())
    {
        yield return it.Next();
        if (it.Error != null)
        {
            onError.Invoke(it.Error, null);
            break;
        }
        if (it.Current != null)
        {
            items.Add(it.Current);
        }
        else
        {
            break;
        }
    }