API Reference of GS2-Stamina SDK for Game Engine

Model

EzStaminaModel

Stamina Model

Parameters such as the maximum value of stamina, recovery interval, and amount of recovery can be defined. You can also control the maximum value and the amount of recovery in conjunction with GS2-Experience.

TypeRequireDefaultLimitationDescription
namestring~ 128 charsStamina Model Name
metadatastring~ 128 charsmetadata
recoverIntervalMinutesint~ 2147483646Speed at which stamina is regained (minutes)
recoverValueint1~ 2147483646Amount of recovery after a period of time
initialCapacityint~ 2147483646Initial maximum value of stamina
isOverflowboolRecover beyond the maximum
maxCapacityint{isOverflow}~ 2147483646Maximum value in overflow situation
maxStaminaTableEzMaxStaminaTableMaximum Stamina Table used when working with GS2-Experience
recoverIntervalTableEzRecoverIntervalTableRecovery interval table used when working with GS2-Experience
recoverValueTableEzRecoverValueTableRecovery amount table used when working with GS2-Experience

EzMaxStaminaTable

Maximum Stamina Table

This entity defines the maximum value of stamina for each rank of GS2-Experience.

TypeRequireDefaultLimitationDescription
namestring~ 128 charsMaximum Stamina Value Table Name
metadatastring~ 128 charsmetadata
experienceModelIdstring~ 1024 charsExperience Model GRN
valuesList<int>List of Maximum Staminas

EzRecoverIntervalTable

Stamina Recovery Interval Table

This entity defines the stamina recovery interval for each rank of GS2-Experience.

TypeRequireDefaultLimitationDescription
namestring~ 128 charsStamina recovery interval table name
metadatastring~ 128 charsmetadata
experienceModelIdstring~ 1024 charsExperience Model GRN
valuesList<int>Stamina recovery interval table for each rank

EzRecoverValueTable

Stamina Recovery Value Table

This entity defines the amount of stamina recovery for each rank of GS2-Experience.

TypeRequireDefaultLimitationDescription
namestring~ 128 charsStamina recovery value table name
metadatastring~ 128 charsmetadata
experienceModelIdstring~ 1024 charsExperience Model GRN
valuesList<int>Stamina recovery value table for each rank

EzStamina

Stamina

Stamina is a point that is recovered over time in real time. Generally, this stamina is used to limit the number of times a player can play a game per day and to allow the game provider to control the speed of game progression by allowing players to consume stamina to play the game.

TypeRequireDefaultLimitationDescription
staminaNamestring~ 128 charsStamina Model Name
valueint~ 2147483646Stamina value
overflowValueint~ 2147483646Stamina value stored in excess of the maximum stamina value
maxValueint1 ~ 2147483646Maximum Stamina
recoverIntervalMinutesint1 ~ 2147483646Stamina recovery interval (minutes)
recoverValueint1 ~ 2147483646Stamina recovery value
nextRecoverAtlongNext time stamina is restored

Methods

getStaminaModel

Get Stamina Model

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
staminaNamestring~ 128 charsStamina Model Name

Result

TypeDescription
itemEzStaminaModelStamina Model

Implementation Example

    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).StaminaModel(
        staminaName: "stamina-0001"
    );
    var item = await domain.ModelAsync();
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).StaminaModel(
        staminaName: "stamina-0001"
    );
    var future = domain.Model();
    yield return future;
    var item = future.Result;
    const auto Domain = Gs2->Stamina->Namespace(
        "namespace-0001" // namespaceName
    )->StaminaModel(
        "stamina-0001" // staminaName
    );
    const auto item = Domain.Model();

listStaminaModels

Get list of stamina models

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name

Result

TypeDescription
itemsList<EzStaminaModel>List of Stamina Models

Implementation Example

    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    );
    var items = await domain.StaminaModelsAsync(
    ).ToListAsync();
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    );
    var it = domain.StaminaModels(
    );
    List<EzStaminaModel> items = new List<EzStaminaModel>();
    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->Stamina->Namespace(
        "namespace-0001" // namespaceName
    );
    const auto It = Domain->StaminaModels(
    );
    for (auto Item : *It)
    {

    }

consume

Consumes stamina

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
staminaNamestring~ 128 charsStamina Model Name
accessTokenstring~ 128 charsUser Id
consumeValueint1 ~ 2147483646Amount of stamina consumed

Result

TypeDescription
itemEzStaminaStamina
staminaModelEzStaminaModelStamina Model

Error

Special exceptions are defined in this API. GS2-SDK for GameEngine provides specialized exceptions derived from general exceptions to facilitate handling of errors that may need to be handled in games. Please refer to the documentation here for more information on common error types and handling methods.

TypeBase TypeDescription
InsufficientExceptionBadRequestExceptionInsufficient remaining stamina.

Implementation Example

try {
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var result = await domain.ConsumeAsync(
        consumeValue: 50
    );
    var item = await result.ModelAsync();
} catch(Gs2.Gs2Stamina.Exception.Insufficient e) {
    // Insufficient remaining stamina.
}
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var future = domain.Consume(
        consumeValue: 50
    );
    yield return future;
    if (future.Error != null)
    {
        if (future.Error is Gs2.Gs2Stamina.Exception.InsufficientException)
        {
            // Insufficient remaining stamina.
        }
        onError.Invoke(future.Error, null);
        yield break;
    }
    var future2 = future.Result.Model();
    yield return future2;
    if (future2.Error != null)
    {
        onError.Invoke(future2.Error, null);
        yield break;
    }
    var result = future2.Result;
    const auto Domain = Gs2->Stamina->Namespace(
        "namespace-0001" // namespaceName
    )->Me(
        AccessToken
    )->Stamina(
        "stamina-0001" // staminaName
    );
    const auto Future = Domain->Consume(
        50
    );
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        if (Gs2::Stamina::Error::FInsufficientError::TypeString == Task->GetTask().Error()->Type())
        {
            // Insufficient remaining stamina.
        }
        return false;
    }

    // obtain changed values / result values
    const auto Future2 = Future->GetTask().Result()->Model();
    Future2->StartSynchronousTask();
    if (!TestFalse(WHAT, Future2->GetTask().IsError())) return false;
    const auto Result = Future2->GetTask().Result();

getStamina

Get current stamina

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
staminaNamestring~ 128 charsStamina Model Name
accessTokenstring~ 128 charsUser Id

Result

TypeDescription
itemEzStaminaStamina
staminaModelEzStaminaModelStamina Model

Implementation Example

    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var item = await domain.ModelAsync();
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var future = domain.Model();
    yield return future;
    var item = future.Result;
    const auto Domain = Gs2->Stamina->Namespace(
        "namespace-0001" // namespaceName
    )->Me(
        AccessToken
    )->Stamina(
        "stamina-0001" // staminaName
    );
    const auto item = Domain.Model();

setMaxValue

Update maximum using GS2-Experience status

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
staminaNamestring~ 128 charsStamina Model Name
accessTokenstring~ 128 charsUser Id
keyIdstring~ 1024 charsencryption key GRN
signedStatusBodystring~ 1048576 charsGS2-Experience status body to be signed
signedStatusSignaturestring~ 128 charsGS2-Experience Status Signature

Result

TypeDescription
itemEzStaminaStamina
staminaModelEzStaminaModelStamina Model

Implementation Example

    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var result = await domain.SetMaxValueAsync(
        keyId: "key-0001",
        signedStatusBody: "$statusBody",
        signedStatusSignature: "$statusSignature"
    );
    var item = await result.ModelAsync();
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var future = domain.SetMaxValue(
        keyId: "key-0001",
        signedStatusBody: "$statusBody",
        signedStatusSignature: "$statusSignature"
    );
    yield return future;
    if (future.Error != null)
    {
        onError.Invoke(future.Error, null);
        yield break;
    }
    var future2 = future.Result.Model();
    yield return future2;
    if (future2.Error != null)
    {
        onError.Invoke(future2.Error, null);
        yield break;
    }
    var result = future2.Result;
    const auto Domain = Gs2->Stamina->Namespace(
        "namespace-0001" // namespaceName
    )->Me(
        AccessToken
    )->Stamina(
        "stamina-0001" // staminaName
    );
    const auto Future = Domain->SetMaxValue(
        "key-0001",
        "$statusBody",
        "$statusSignature"
    );
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

    // obtain changed values / result values
    const auto Future2 = Future->GetTask().Result()->Model();
    Future2->StartSynchronousTask();
    if (!TestFalse(WHAT, Future2->GetTask().IsError())) return false;
    const auto Result = Future2->GetTask().Result();

setRecoverInterval

Update recover interval using GS2-Experience status

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
staminaNamestring~ 128 charsStamina Model Name
accessTokenstring~ 128 charsUser Id
keyIdstring~ 1024 charsencryption key GRN
signedStatusBodystring~ 1048576 charsGS2-Experience status body to be signed
signedStatusSignaturestring~ 128 charsGS2-Experience Status Signature

Result

TypeDescription
itemEzStaminaStamina
staminaModelEzStaminaModelStamina Model

Implementation Example

    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var result = await domain.SetRecoverIntervalAsync(
        keyId: "key-0001",
        signedStatusBody: "$statusBody",
        signedStatusSignature: "$statusSignature"
    );
    var item = await result.ModelAsync();
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var future = domain.SetRecoverInterval(
        keyId: "key-0001",
        signedStatusBody: "$statusBody",
        signedStatusSignature: "$statusSignature"
    );
    yield return future;
    if (future.Error != null)
    {
        onError.Invoke(future.Error, null);
        yield break;
    }
    var future2 = future.Result.Model();
    yield return future2;
    if (future2.Error != null)
    {
        onError.Invoke(future2.Error, null);
        yield break;
    }
    var result = future2.Result;
    const auto Domain = Gs2->Stamina->Namespace(
        "namespace-0001" // namespaceName
    )->Me(
        AccessToken
    )->Stamina(
        "stamina-0001" // staminaName
    );
    const auto Future = Domain->SetRecoverInterval(
        "key-0001",
        "$statusBody",
        "$statusSignature"
    );
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

    // obtain changed values / result values
    const auto Future2 = Future->GetTask().Result()->Model();
    Future2->StartSynchronousTask();
    if (!TestFalse(WHAT, Future2->GetTask().IsError())) return false;
    const auto Result = Future2->GetTask().Result();

setRecoverValue

Update recover value using GS2-Experience status

Request

TypeRequireDefaultLimitationDescription
namespaceNamestring~ 32 charsNamespace name
staminaNamestring~ 128 charsStamina Model Name
accessTokenstring~ 128 charsUser Id
keyIdstring~ 1024 charsencryption key GRN
signedStatusBodystring~ 1048576 charsGS2-Experience status body to be signed
signedStatusSignaturestring~ 128 charsGS2-Experience Status Signature

Result

TypeDescription
itemEzStaminaStamina
staminaModelEzStaminaModelStamina Model

Implementation Example

    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var result = await domain.SetRecoverValueAsync(
        keyId: "key-0001",
        signedStatusBody: "$statusBody",
        signedStatusSignature: "$statusSignature"
    );
    var item = await result.ModelAsync();
    var domain = gs2.Stamina.Namespace(
        namespaceName: "namespace-0001"
    ).Me(
        gameSession: GameSession
    ).Stamina(
        staminaName: "stamina-0001"
    );
    var future = domain.SetRecoverValue(
        keyId: "key-0001",
        signedStatusBody: "$statusBody",
        signedStatusSignature: "$statusSignature"
    );
    yield return future;
    if (future.Error != null)
    {
        onError.Invoke(future.Error, null);
        yield break;
    }
    var future2 = future.Result.Model();
    yield return future2;
    if (future2.Error != null)
    {
        onError.Invoke(future2.Error, null);
        yield break;
    }
    var result = future2.Result;
    const auto Domain = Gs2->Stamina->Namespace(
        "namespace-0001" // namespaceName
    )->Me(
        AccessToken
    )->Stamina(
        "stamina-0001" // staminaName
    );
    const auto Future = Domain->SetRecoverValue(
        "key-0001",
        "$statusBody",
        "$statusSignature"
    );
    Future->StartSynchronousTask();
    if (Future->GetTask().IsError())
    {
        return false;
    }

    // obtain changed values / result values
    const auto Future2 = Future->GetTask().Result()->Model();
    Future2->StartSynchronousTask();
    if (!TestFalse(WHAT, Future2->GetTask().IsError())) return false;
    const auto Result = Future2->GetTask().Result();