NAV Navbar
Python Java GS2-Formation
 

GS2-Stamina

現実時間経過によって回復するスタミナ値を実現します。

スタミナには回復間隔と回復量を設定できます。 スタミナには2段階の最大値を設定できます。 1つ目は時間経過による自然回復の最大値。2つ目はUIの都合による最大値です。

GS2では、レベルアップ時にスタミナを全回復するときに公平性を期するため、自然回復の最大値を超えて回復できるようにしています。 一方で、これを無制限に許可してしまうと、UIに破綻をきたしてしまう可能性があります。 そのため、二段階目の最大値を設けており、仮にこちらを超えるようなことが会っても GS2-Distributor を使用していればプレゼントボックスにスタミナ回復リソースを届けられるようになっています。

この仕組みを応用すると、街づくりゲームの採集機能も実装できます。 スタミナモデルに建築物を設定し、スタミナ値を建築物の生産量をとして表現します。

モデル

Namespace

ネームスペース

ネームスペースにはスタミナモデル(スタミナの最大値や回復速度・量)を最大100種類指定できます。 100種類超える見込みがある場合はネームスペースをスタミナのカテゴリごとに分割することを事前に検討してください。

ネームスペースを分割することで生じるデメリットとして、特定のゲームプレイヤーに関するスタミナ情報の一覧を取得したり、スタミナモデルのマスターデータを取得する際にネームスペースを超えて同時に取得することはできないことがあります。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false 説明文
overflowTriggerScriptId string false スタミナオーバーフロー上限に当たって回復できなかったスタミナを通知する スクリプト のGRN
overflowTriggerQueueId string false スタミナオーバーフロー上限に当たって回復できなかったスタミナを追加する ネームスペース のGRN
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

StaminaModelMaster

スタミナモデルマスター

スタミナの回復間隔や回復量、最大値を設定する。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
staminaModelId string true スタミナモデルマスター
name string true スタミナの種類名
metadata string false スタミナの種類のメタデータ
description string false スタミナモデルマスターの説明
recoverIntervalMinutes integer true スタミナを回復する速度(分)
recoverValue integer true 時間経過後に回復する量
initialCapacity integer true スタミナの最大値の初期値
isOverflow boolean true 最大値を超えて回復するか
maxCapacity integer true 溢れた状況での最大値
maxStaminaTableId string false GS2-Experience のランクによって最大スタミナ値を決定する
recoverIntervalTableId string false GS2-Experience のランクによってスタミナの回復間隔を決定する
recoverValueTableId string false GS2-Experience のランクによってスタミナの回復量を決定する
createdAt long true 作成日時
updatedAt long true 最終更新日時

MaxStaminaTableMaster

スタミナの最大値テーブルマスター

GS2-Experience のランクに基づいてスタミナの最大値を決定するためのテーブル。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
maxStaminaTableId string true スタミナの最大値テーブルマスター
name string true 最大スタミナ値テーブル名
metadata string false 最大スタミナ値テーブルのメタデータ
description string false スタミナの最大値テーブルマスターの説明
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナの最大値テーブル

RecoverIntervalTableMaster

スタミナ回復間隔テーブルマスター

GS2-Experience のランクに基づいてスタミナ回復間隔を決定するためのテーブル。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
recoverIntervalTableId string true スタミナ回復間隔テーブルマスター
name string true スタミナ回復間隔テーブル名
metadata string false スタミナ回復間隔テーブルのメタデータ
description string false スタミナ回復間隔テーブルマスターの説明
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復間隔テーブル

RecoverValueTableMaster

スタミナ回復量テーブルマスター

GS2-Experience のランクに基づいてスタミナ回復量を決定するためのテーブル。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
recoverValueTableId string true スタミナ回復量テーブルマスター
name string true スタミナ回復量テーブル名
metadata string false スタミナ回復量テーブルのメタデータ
description string false スタミナ回復量テーブルマスターの説明
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復量テーブル

CurrentStaminaMaster

現在有効なスタミナマスター

エクスポートしたマスターデータを、現在有効なスタミナマスターとしてインポートして使用します。

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
settings string true マスターデータ

StaminaModel

スタミナモデル

スタミナの回復間隔や回復量、最大値を設定する。

パラメータ データ型 必須 説明
staminaModelId string true スタミナモデルマスター
name string true スタミナの種類名
metadata string false スタミナの種類のメタデータ
recoverIntervalMinutes integer true スタミナを回復する速度(分)
recoverValue integer true 時間経過後に回復する量
initialCapacity integer true スタミナの最大値の初期値
isOverflow boolean true 最大値を超えて回復するか
maxCapacity integer true 溢れた状況での最大値
maxStaminaTable MaxStaminaTable false GS2-Experience と連携する際に使用するスタミナ最大値テーブル
recoverIntervalTable RecoverIntervalTable false GS2-Experience と連携する際に使用する回復間隔テーブル
recoverValueTable RecoverValueTable false GS2-Experience と連携する際に使用する回復量テーブル

MaxStaminaTable

スタミナの最大値テーブル

GS2-Experience のランクに基づいてスタミナの最大値を決定するためのテーブル。

パラメータ データ型 必須 説明
maxStaminaTableId string true スタミナの最大値テーブルマスター
name string true 最大スタミナ値テーブル名
metadata string false 最大スタミナ値テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナの最大値テーブル

RecoverIntervalTable

スタミナ回復間隔テーブル

GS2-Experience のランクに基づいてスタミナ回復間隔を決定するためのテーブル。

パラメータ データ型 必須 説明
recoverIntervalTableId string true スタミナ回復間隔テーブルマスター
name string true スタミナ回復間隔テーブル名
metadata string false スタミナ回復間隔テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復間隔テーブル

RecoverValueTable

スタミナ回復量テーブル

GS2-Experience のランクに基づいてスタミナ回復量を決定するためのテーブル。

パラメータ データ型 必須 説明
recoverValueTableId string true スタミナ回復量テーブルマスター
name string true スタミナ回復量テーブル名
metadata string false スタミナ回復量テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復量テーブル

Stamina

スタミナ

プレイヤーのスタミナ値

パラメータ データ型 必須 説明
staminaId string true スタミナ
staminaName string true スタミナモデルの名前
userId string false ユーザーID
value integer true 最終更新時におけるスタミナ値
maxValue integer true スタミナの最大値
recoverIntervalMinutes integer false スタミナの回復間隔(分)
recoverValue integer false スタミナの回復量
overflowValue integer true スタミナの最大値を超えて格納されているスタミナ値
nextRecoverAt long false 次回スタミナが回復する時間
lastRecoveredAt long false 作成日時
createdAt long true 作成日時
updatedAt long true 最終更新日時

ResponseCache

レスポンスキャッシュ

パラメータ データ型 必須 説明
region string false
ownerId string true オーナーID
responseCacheId string true レスポンスキャッシュ のGRN
requestHash string false
result string true APIの応答内容

GitHubCheckoutSetting

GitHubからリソースをチェックアウトしてくる設定

パラメータ データ型 必須 説明
apiKeyId string true リソースの取得に使用するGitHub のAPIキー のGRN
repositoryName string true リポジトリ名
sourcePath string true ソースコードのファイルパス
referenceType string true コードの取得元
commitHash string true コミットハッシュ
branchName string true ブランチ名
tagName string true タグ名

LogSetting

ロギング通知設定

パラメータ データ型 必須 説明
loggingNamespaceId string false ログの記録に使用する GS2-Log のネームスペース のGRN

初期化処理

HTTPプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_stamina_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2StaminaRestClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.stamina.rest.Gs2StaminaRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)
session.connect()
Gs2StaminaRestClient client = new Gs2StaminaRestClient(session)
初期化処理は不要です

HTTPプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_stamina_client.rest.*

session = Gs2RestSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2StaminaRestClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.rest.Gs2RestSession
import io.gs2.stamina.rest.Gs2StaminaRestClient

Gs2RestSession session = new Gs2RestSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2StaminaRestClient client = new Gs2StaminaRestClient(session)
    }
)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 同期処理

import gs2_core_client.model.*
import gs2_stamina_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)
session.connect()
client = Gs2StaminaWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.stamina.webSocket.Gs2StaminaWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect()
Gs2StaminaWebSocketClient client = new Gs2StaminaWebSocketClient(session)
初期化処理は不要です

WebSocketプロトコル クライアントの初期化 非同期処理

import gs2_core_client.model.*
import gs2_stamina_client.web_socket.*

session = Gs2WebSocketSession(
    region=Region.AP_NORTHEAST_1,
    credential=BasicGs2Credential(
        client_id='your client id',
        client_secret='your client secret',
    ),
)

def complete(result: AsyncResult[None]):
    client = Gs2StaminaWebSocketClient(session)

session.connect_async(
    complete,
)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.stamina.webSocket.Gs2StaminaWebSocketClient

Gs2WebSocketSession session = new Gs2WebSocketSession(
    Region.AP_NORTHEAST_1,
    new BasicGs2Credential(
        'your client id',
        'your client secret'
    )
)

session.connect_async(
    (result) => {
        Gs2StaminaWebSocketClient client = new Gs2StaminaWebSocketClient(session)
    }
)
初期化処理は不要です

GS2-Stamina は HTTPプロトコル と WebSocketプロトコル の2種類のプロトコルをサポートしています。

HTTPプロトコル と WebSocketプロトコル の違いは以下に示すとおりです。

HTTP WebSocket
接続方式 都度接続 常時接続
応答性能 優れている
API制限 なし 大容量のデータをやりとりするAPIには使用不可(主にマスターデータ系処理)
利用料金 WebSocketと同一 HTTPと同一

終了処理

HTTPプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

WebSocketプロトコル クライアントの終了処理

session.disconnect()
session.disconnect();
終了処理は不要です

session オブジェクトの切断処理を行って終了処理を行います。 同一 session オブジェクトを複数の異なる Client オブジェクトに渡すことができます。

メソッド

consumeStamina

同期処理

from gs2_stamina_client.request import ConsumeStaminaRequest
from gs2_stamina_client.result import ConsumeStaminaResult

result = client.consume_stamina(
    ConsumeStaminaRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0001')\
        .with_consume_value(10)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.ConsumeStaminaRequest
import io.gs2.stamina.result.ConsumeStaminaResult

result = client.consumeStamina(
    ConsumeStaminaRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0001")
        .withConsumeValue(10)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import ConsumeStaminaRequest
from gs2_stamina_client.result import ConsumeStaminaResult

def callback(async_result: AsyncResult[ConsumeStaminaResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.consume_stamina_async(
    ConsumeStaminaRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0001')\
        .with_consume_value(10),
    callback
)
import io.gs2.stamina.request.ConsumeStaminaRequest
import io.gs2.stamina.result.ConsumeStaminaResult

result = client.consumeStamina(
    ConsumeStaminaRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0001")
        .withConsumeValue(10),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナを消費

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
consumeValue integer true 消費するスタミナ量
パラメータ データ型 説明
item Stamina スタミナ

consumeStaminaByStampTask

同期処理

from gs2_stamina_client.request import ConsumeStaminaByStampTaskRequest
from gs2_stamina_client.result import ConsumeStaminaByStampTaskResult

result = client.consume_stamina_by_stamp_task(
    ConsumeStaminaByStampTaskRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.ConsumeStaminaByStampTaskRequest
import io.gs2.stamina.result.ConsumeStaminaByStampTaskResult

result = client.consumeStaminaByStampTask(
    ConsumeStaminaByStampTaskRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import ConsumeStaminaByStampTaskRequest
from gs2_stamina_client.result import ConsumeStaminaByStampTaskResult

def callback(async_result: AsyncResult[ConsumeStaminaByStampTaskResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.consume_stamina_by_stamp_task_async(
    ConsumeStaminaByStampTaskRequest()\
    callback
)
import io.gs2.stamina.request.ConsumeStaminaByStampTaskRequest
import io.gs2.stamina.result.ConsumeStaminaByStampTaskResult

result = client.consumeStaminaByStampTask(
    ConsumeStaminaByStampTaskRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプタスクを使用してスタミナを消費

パラメータ データ型 必須 説明
stampTask string true スタンプタスク
keyId string true スタンプタスクの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Stamina スタミナ
newContextStack string スタンプタスクの実行結果を記録したコンテキスト

consumeStaminaByUserId

同期処理

from gs2_stamina_client.request import ConsumeStaminaByUserIdRequest
from gs2_stamina_client.result import ConsumeStaminaByUserIdResult

result = client.consume_stamina_by_user_id(
    ConsumeStaminaByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0002')\
        .with_user_id('user-0001')\
        .with_consume_value(5)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.ConsumeStaminaByUserIdRequest
import io.gs2.stamina.result.ConsumeStaminaByUserIdResult

result = client.consumeStaminaByUserId(
    ConsumeStaminaByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0002")
        .withUserId("user-0001")
        .withConsumeValue(5)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import ConsumeStaminaByUserIdRequest
from gs2_stamina_client.result import ConsumeStaminaByUserIdResult

def callback(async_result: AsyncResult[ConsumeStaminaByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.consume_stamina_by_user_id_async(
    ConsumeStaminaByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0002')\
        .with_user_id('user-0001')\
        .with_consume_value(5),
    callback
)
import io.gs2.stamina.request.ConsumeStaminaByUserIdRequest
import io.gs2.stamina.result.ConsumeStaminaByUserIdResult

result = client.consumeStaminaByUserId(
    ConsumeStaminaByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0002")
        .withUserId("user-0001")
        .withConsumeValue(5),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナを消費

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
consumeValue integer true 消費するスタミナ量
パラメータ データ型 説明
item Stamina スタミナ

createMaxStaminaTableMaster

同期処理

from gs2_stamina_client.request import CreateMaxStaminaTableMasterRequest
from gs2_stamina_client.result import CreateMaxStaminaTableMasterResult

result = client.create_max_stamina_table_master(
    CreateMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('max-stamina-table-0001')\
        .with_experience_model_id('experienceModelId-0001')\
        .with_values([
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.CreateMaxStaminaTableMasterRequest
import io.gs2.stamina.result.CreateMaxStaminaTableMasterResult

result = client.createMaxStaminaTableMaster(
    CreateMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("max-stamina-table-0001")
        .withExperienceModelId("experienceModelId-0001")
        .withValues(new [] {
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import CreateMaxStaminaTableMasterRequest
from gs2_stamina_client.result import CreateMaxStaminaTableMasterResult

def callback(async_result: AsyncResult[CreateMaxStaminaTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_max_stamina_table_master_async(
    CreateMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('max-stamina-table-0001')\
        .with_experience_model_id('experienceModelId-0001')\
        .with_values([
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
]),
    callback
)
import io.gs2.stamina.request.CreateMaxStaminaTableMasterRequest
import io.gs2.stamina.result.CreateMaxStaminaTableMasterResult

result = client.createMaxStaminaTableMaster(
    CreateMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("max-stamina-table-0001")
        .withExperienceModelId("experienceModelId-0001")
        .withValues(new [] {
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Stamina::MaxStaminaTableMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ExperienceModelId: String
  Values:
    - Integer
    - Integer

スタミナの最大値テーブルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 最大スタミナ値テーブル名
description string false スタミナの最大値テーブルマスターの説明
metadata string false 最大スタミナ値テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナの最大値テーブル
パラメータ データ型 説明
item MaxStaminaTableMaster 作成したスタミナの最大値テーブルマスター

createNamespace

同期処理

from gs2_stamina_client.request import CreateNamespaceRequest
from gs2_stamina_client.result import CreateNamespaceResult

result = client.create_namespace(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.CreateNamespaceRequest
import io.gs2.stamina.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import CreateNamespaceRequest
from gs2_stamina_client.result import CreateNamespaceResult

def callback(async_result: AsyncResult[CreateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_namespace_async(
    CreateNamespaceRequest()\
        .with_name('namespace-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.stamina.request.CreateNamespaceRequest
import io.gs2.stamina.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespace-0001")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Stamina::Namespace
Properties:
  Name: String
  Description: Optional[String]
  OverflowTriggerScriptId: Optional[String]
  OverflowTriggerNamespaceId: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

ネームスペースを新規作成

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false 説明文
overflowTriggerScriptId string false スタミナオーバーフロー上限に当たって回復できなかったスタミナを通知する スクリプト のGRN
overflowTriggerNamespaceId string false スタミナオーバーフロー上限に当たって回復できなかったスタミナを追加する ネームスペース のGRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createRecoverIntervalTableMaster

同期処理

from gs2_stamina_client.request import CreateRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import CreateRecoverIntervalTableMasterResult

result = client.create_recover_interval_table_master(
    CreateRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('recover-interval-table-0001')\
        .with_experience_model_id('experienceModelId-0001')\
        .with_values([
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.CreateRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.CreateRecoverIntervalTableMasterResult

result = client.createRecoverIntervalTableMaster(
    CreateRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("recover-interval-table-0001")
        .withExperienceModelId("experienceModelId-0001")
        .withValues(new [] {
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import CreateRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import CreateRecoverIntervalTableMasterResult

def callback(async_result: AsyncResult[CreateRecoverIntervalTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_recover_interval_table_master_async(
    CreateRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('recover-interval-table-0001')\
        .with_experience_model_id('experienceModelId-0001')\
        .with_values([
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
]),
    callback
)
import io.gs2.stamina.request.CreateRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.CreateRecoverIntervalTableMasterResult

result = client.createRecoverIntervalTableMaster(
    CreateRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("recover-interval-table-0001")
        .withExperienceModelId("experienceModelId-0001")
        .withValues(new [] {
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Stamina::RecoverIntervalTableMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ExperienceModelId: String
  Values:
    - Integer
    - Integer

スタミナ回復間隔テーブルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true スタミナ回復間隔テーブル名
description string false スタミナ回復間隔テーブルマスターの説明
metadata string false スタミナ回復間隔テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復間隔テーブル
パラメータ データ型 説明
item RecoverIntervalTableMaster 作成したスタミナ回復間隔テーブルマスター

createRecoverValueTableMaster

同期処理

from gs2_stamina_client.request import CreateRecoverValueTableMasterRequest
from gs2_stamina_client.result import CreateRecoverValueTableMasterResult

result = client.create_recover_value_table_master(
    CreateRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('recover-value-table-0001')\
        .with_experience_model_id('experienceModelId-0001')\
        .with_values([
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.CreateRecoverValueTableMasterRequest
import io.gs2.stamina.result.CreateRecoverValueTableMasterResult

result = client.createRecoverValueTableMaster(
    CreateRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("recover-value-table-0001")
        .withExperienceModelId("experienceModelId-0001")
        .withValues(new [] {
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import CreateRecoverValueTableMasterRequest
from gs2_stamina_client.result import CreateRecoverValueTableMasterResult

def callback(async_result: AsyncResult[CreateRecoverValueTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_recover_value_table_master_async(
    CreateRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('recover-value-table-0001')\
        .with_experience_model_id('experienceModelId-0001')\
        .with_values([
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
]),
    callback
)
import io.gs2.stamina.request.CreateRecoverValueTableMasterRequest
import io.gs2.stamina.result.CreateRecoverValueTableMasterResult

result = client.createRecoverValueTableMaster(
    CreateRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("recover-value-table-0001")
        .withExperienceModelId("experienceModelId-0001")
        .withValues(new [] {
0,  
100,    
200,    
300,    
400,    
500,    
600,    
700,    
800,    
900,    
1000,   
1100,   
1200,   
1300,   
1400,   
1500,   
1600,   
1700,   
1800,   
1900,   
2000,   
2100,   
2200,   
2300,   
2400,   
2500,   
2600,   
2700,   
2800,   
2900,   
3000,   
3100,   
3200,   
3300,   
3400,   
3500,   
3600,   
3700,   
3800,   
3900,   
4000,   
4100,   
4200,   
4300,   
4400,   
4500,   
4600,   
4700,   
4800,   
4900,   
5000,   
5100,   
5200,   
5300,   
5400,   
5500,   
5600,   
5700,   
5800,   
5900,   
6000,   
6100,   
6200,   
6300,   
6400,   
6500,   
6600,   
6700,   
6800,   
6900,   
7000,   
7100,   
7200,   
7300,   
7400,   
7500,   
7600,   
7700,   
7800,   
7900,   
8000,   
8100,   
8200,   
8300,   
8400,   
8500,   
8600,   
8700,   
8800,   
8900,   
9000,   
9100,   
9200,   
9300,   
9400,   
9500,   
9600,   
9700,   
9800,   
9900
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Stamina::RecoverValueTableMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ExperienceModelId: String
  Values:
    - Integer
    - Integer

スタミナ回復量テーブルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true スタミナ回復量テーブル名
description string false スタミナ回復量テーブルマスターの説明
metadata string false スタミナ回復量テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復量テーブル
パラメータ データ型 説明
item RecoverValueTableMaster 作成したスタミナ回復量テーブルマスター

createStaminaModelMaster

同期処理

from gs2_stamina_client.request import CreateStaminaModelMasterRequest
from gs2_stamina_client.result import CreateStaminaModelMasterResult

result = client.create_stamina_model_master(
    CreateStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('stamina-0001')\
        .with_recover_interval_minutes(15)\
        .with_initial_capacity(50)\
        .with_is_overflow(False)\
        .with_max_stamina_table_id(max_stamina_table1['maxStaminaTableId'])\
        .with_recover_interval_table_id(recover_interval_table1['recoverIntervalTableId'])\
        .with_recover_value_table_id(recover_value_table1['recoverValueTableId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.CreateStaminaModelMasterRequest
import io.gs2.stamina.result.CreateStaminaModelMasterResult

result = client.createStaminaModelMaster(
    CreateStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("stamina-0001")
        .withRecoverIntervalMinutes(15)
        .withInitialCapacity(50)
        .withIsOverflow(false)
        .withMaxStaminaTableId(max_stamina_table1.get'MaxStaminaTableId())
        .withRecoverIntervalTableId(recover_interval_table1.get'RecoverIntervalTableId())
        .withRecoverValueTableId(recover_value_table1.get'RecoverValueTableId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import CreateStaminaModelMasterRequest
from gs2_stamina_client.result import CreateStaminaModelMasterResult

def callback(async_result: AsyncResult[CreateStaminaModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.create_stamina_model_master_async(
    CreateStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_name('stamina-0001')\
        .with_recover_interval_minutes(15)\
        .with_initial_capacity(50)\
        .with_is_overflow(False)\
        .with_max_stamina_table_id(max_stamina_table1['maxStaminaTableId'])\
        .with_recover_interval_table_id(recover_interval_table1['recoverIntervalTableId'])\
        .with_recover_value_table_id(recover_value_table1['recoverValueTableId']),
    callback
)
import io.gs2.stamina.request.CreateStaminaModelMasterRequest
import io.gs2.stamina.result.CreateStaminaModelMasterResult

result = client.createStaminaModelMaster(
    CreateStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withName("stamina-0001")
        .withRecoverIntervalMinutes(15)
        .withInitialCapacity(50)
        .withIsOverflow(false)
        .withMaxStaminaTableId(max_stamina_table1.get'MaxStaminaTableId())
        .withRecoverIntervalTableId(recover_interval_table1.get'RecoverIntervalTableId())
        .withRecoverValueTableId(recover_value_table1.get'RecoverValueTableId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Stamina::StaminaModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  RecoverIntervalMinutes: Integer
  RecoverValue: Integer
  InitialCapacity: Integer
  IsOverflow: Bool
  MaxCapacity: Integer
  MaxStaminaTableId: Optional[String]
  RecoverIntervalTableId: Optional[String]
  RecoverValueTableId: Optional[String]

スタミナモデルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true スタミナの種類名
description string false スタミナモデルマスターの説明
metadata string false スタミナの種類のメタデータ
recoverIntervalMinutes integer true スタミナを回復する速度(分)
recoverValue integer true 時間経過後に回復する量
initialCapacity integer true スタミナの最大値の初期値
isOverflow boolean true 最大値を超えて回復するか
maxCapacity integer true 溢れた状況での最大値
maxStaminaTableId string false GS2-Experience のランクによって最大スタミナ値を決定する
recoverIntervalTableId string false GS2-Experience のランクによってスタミナの回復間隔を決定する
recoverValueTableId string false GS2-Experience のランクによってスタミナの回復量を決定する
パラメータ データ型 説明
item StaminaModelMaster 作成したスタミナモデルマスター

deleteMaxStaminaTableMaster

同期処理

from gs2_stamina_client.request import DeleteMaxStaminaTableMasterRequest
from gs2_stamina_client.result import DeleteMaxStaminaTableMasterResult

result = client.delete_max_stamina_table_master(
    DeleteMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_max_stamina_table_name('max-stamina-table-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DeleteMaxStaminaTableMasterRequest
import io.gs2.stamina.result.DeleteMaxStaminaTableMasterResult

result = client.deleteMaxStaminaTableMaster(
    DeleteMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withMaxStaminaTableName("max-stamina-table-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DeleteMaxStaminaTableMasterRequest
from gs2_stamina_client.result import DeleteMaxStaminaTableMasterResult

def callback(async_result: AsyncResult[DeleteMaxStaminaTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_max_stamina_table_master_async(
    DeleteMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_max_stamina_table_name('max-stamina-table-0001'),
    callback
)
import io.gs2.stamina.request.DeleteMaxStaminaTableMasterRequest
import io.gs2.stamina.result.DeleteMaxStaminaTableMasterResult

result = client.deleteMaxStaminaTableMaster(
    DeleteMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withMaxStaminaTableName("max-stamina-table-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値テーブルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
maxStaminaTableName string true 最大スタミナ値テーブル名
パラメータ データ型 説明
item MaxStaminaTableMaster 削除したスタミナの最大値テーブルマスター

deleteNamespace

同期処理

from gs2_stamina_client.request import DeleteNamespaceRequest
from gs2_stamina_client.result import DeleteNamespaceResult

result = client.delete_namespace(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DeleteNamespaceRequest
import io.gs2.stamina.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DeleteNamespaceRequest
from gs2_stamina_client.result import DeleteNamespaceResult

def callback(async_result: AsyncResult[DeleteNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_namespace_async(
    DeleteNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.DeleteNamespaceRequest
import io.gs2.stamina.result.DeleteNamespaceResult

result = client.deleteNamespace(
    DeleteNamespaceRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace 削除したネームスペース

deleteRecoverIntervalTableMaster

同期処理

from gs2_stamina_client.request import DeleteRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import DeleteRecoverIntervalTableMasterResult

result = client.delete_recover_interval_table_master(
    DeleteRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_interval_table_name('recover-interval-table-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DeleteRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.DeleteRecoverIntervalTableMasterResult

result = client.deleteRecoverIntervalTableMaster(
    DeleteRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverIntervalTableName("recover-interval-table-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DeleteRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import DeleteRecoverIntervalTableMasterResult

def callback(async_result: AsyncResult[DeleteRecoverIntervalTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_recover_interval_table_master_async(
    DeleteRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_interval_table_name('recover-interval-table-0001'),
    callback
)
import io.gs2.stamina.request.DeleteRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.DeleteRecoverIntervalTableMasterResult

result = client.deleteRecoverIntervalTableMaster(
    DeleteRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverIntervalTableName("recover-interval-table-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復間隔テーブルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
recoverIntervalTableName string true スタミナ回復間隔テーブル名
パラメータ データ型 説明
item RecoverIntervalTableMaster 削除したスタミナ回復間隔テーブルマスター

deleteRecoverValueTableMaster

同期処理

from gs2_stamina_client.request import DeleteRecoverValueTableMasterRequest
from gs2_stamina_client.result import DeleteRecoverValueTableMasterResult

result = client.delete_recover_value_table_master(
    DeleteRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_value_table_name('recover-value-table-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DeleteRecoverValueTableMasterRequest
import io.gs2.stamina.result.DeleteRecoverValueTableMasterResult

result = client.deleteRecoverValueTableMaster(
    DeleteRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverValueTableName("recover-value-table-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DeleteRecoverValueTableMasterRequest
from gs2_stamina_client.result import DeleteRecoverValueTableMasterResult

def callback(async_result: AsyncResult[DeleteRecoverValueTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_recover_value_table_master_async(
    DeleteRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_value_table_name('recover-value-table-0001'),
    callback
)
import io.gs2.stamina.request.DeleteRecoverValueTableMasterRequest
import io.gs2.stamina.result.DeleteRecoverValueTableMasterResult

result = client.deleteRecoverValueTableMaster(
    DeleteRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverValueTableName("recover-value-table-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復量テーブルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
recoverValueTableName string true スタミナ回復量テーブル名
パラメータ データ型 説明
item RecoverValueTableMaster 削除したスタミナ回復量テーブルマスター

deleteStaminaByUserId

同期処理

from gs2_stamina_client.request import DeleteStaminaByUserIdRequest
from gs2_stamina_client.result import DeleteStaminaByUserIdResult

result = client.delete_stamina_by_user_id(
    DeleteStaminaByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DeleteStaminaByUserIdRequest
import io.gs2.stamina.result.DeleteStaminaByUserIdResult

result = client.deleteStaminaByUserId(
    DeleteStaminaByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0001")
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DeleteStaminaByUserIdRequest
from gs2_stamina_client.result import DeleteStaminaByUserIdResult

def callback(async_result: AsyncResult[DeleteStaminaByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_stamina_by_user_id_async(
    DeleteStaminaByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.stamina.request.DeleteStaminaByUserIdRequest
import io.gs2.stamina.result.DeleteStaminaByUserIdResult

result = client.deleteStaminaByUserId(
    DeleteStaminaByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0001")
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
パラメータ データ型 説明

deleteStaminaModelMaster

同期処理

from gs2_stamina_client.request import DeleteStaminaModelMasterRequest
from gs2_stamina_client.result import DeleteStaminaModelMasterResult

result = client.delete_stamina_model_master(
    DeleteStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DeleteStaminaModelMasterRequest
import io.gs2.stamina.result.DeleteStaminaModelMasterResult

result = client.deleteStaminaModelMaster(
    DeleteStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DeleteStaminaModelMasterRequest
from gs2_stamina_client.result import DeleteStaminaModelMasterResult

def callback(async_result: AsyncResult[DeleteStaminaModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.delete_stamina_model_master_async(
    DeleteStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001'),
    callback
)
import io.gs2.stamina.request.DeleteStaminaModelMasterRequest
import io.gs2.stamina.result.DeleteStaminaModelMasterResult

result = client.deleteStaminaModelMaster(
    DeleteStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナモデルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
パラメータ データ型 説明
item StaminaModelMaster 削除したスタミナモデルマスター

describeMaxStaminaTableMasters

同期処理

from gs2_stamina_client.request import DescribeMaxStaminaTableMastersRequest
from gs2_stamina_client.result import DescribeMaxStaminaTableMastersResult

result = client.describe_max_stamina_table_masters(
    DescribeMaxStaminaTableMastersRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeMaxStaminaTableMastersRequest
import io.gs2.stamina.result.DescribeMaxStaminaTableMastersResult

result = client.describeMaxStaminaTableMasters(
    DescribeMaxStaminaTableMastersRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeMaxStaminaTableMastersRequest
from gs2_stamina_client.result import DescribeMaxStaminaTableMastersResult

def callback(async_result: AsyncResult[DescribeMaxStaminaTableMastersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_max_stamina_table_masters_async(
    DescribeMaxStaminaTableMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.DescribeMaxStaminaTableMastersRequest
import io.gs2.stamina.result.DescribeMaxStaminaTableMastersResult

result = client.describeMaxStaminaTableMasters(
    DescribeMaxStaminaTableMastersRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値テーブルマスターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[MaxStaminaTableMaster] スタミナの最大値テーブルマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeNamespaces

同期処理

from gs2_stamina_client.request import DescribeNamespacesRequest
from gs2_stamina_client.result import DescribeNamespacesResult

result = client.describe_namespaces(
    DescribeNamespacesRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeNamespacesRequest
import io.gs2.stamina.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeNamespacesRequest
from gs2_stamina_client.result import DescribeNamespacesResult

def callback(async_result: AsyncResult[DescribeNamespacesResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_namespaces_async(
    DescribeNamespacesRequest()\
    callback
)
import io.gs2.stamina.request.DescribeNamespacesRequest
import io.gs2.stamina.result.DescribeNamespacesResult

result = client.describeNamespaces(
    DescribeNamespacesRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースの一覧を取得

パラメータ データ型 必須 説明
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Namespace] ネームスペースのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeRecoverIntervalTableMasters

同期処理

from gs2_stamina_client.request import DescribeRecoverIntervalTableMastersRequest
from gs2_stamina_client.result import DescribeRecoverIntervalTableMastersResult

result = client.describe_recover_interval_table_masters(
    DescribeRecoverIntervalTableMastersRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeRecoverIntervalTableMastersRequest
import io.gs2.stamina.result.DescribeRecoverIntervalTableMastersResult

result = client.describeRecoverIntervalTableMasters(
    DescribeRecoverIntervalTableMastersRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeRecoverIntervalTableMastersRequest
from gs2_stamina_client.result import DescribeRecoverIntervalTableMastersResult

def callback(async_result: AsyncResult[DescribeRecoverIntervalTableMastersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_recover_interval_table_masters_async(
    DescribeRecoverIntervalTableMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.DescribeRecoverIntervalTableMastersRequest
import io.gs2.stamina.result.DescribeRecoverIntervalTableMastersResult

result = client.describeRecoverIntervalTableMasters(
    DescribeRecoverIntervalTableMastersRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復間隔テーブルマスターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[RecoverIntervalTableMaster] スタミナ回復間隔テーブルマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeRecoverValueTableMasters

同期処理

from gs2_stamina_client.request import DescribeRecoverValueTableMastersRequest
from gs2_stamina_client.result import DescribeRecoverValueTableMastersResult

result = client.describe_recover_value_table_masters(
    DescribeRecoverValueTableMastersRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeRecoverValueTableMastersRequest
import io.gs2.stamina.result.DescribeRecoverValueTableMastersResult

result = client.describeRecoverValueTableMasters(
    DescribeRecoverValueTableMastersRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeRecoverValueTableMastersRequest
from gs2_stamina_client.result import DescribeRecoverValueTableMastersResult

def callback(async_result: AsyncResult[DescribeRecoverValueTableMastersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_recover_value_table_masters_async(
    DescribeRecoverValueTableMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.DescribeRecoverValueTableMastersRequest
import io.gs2.stamina.result.DescribeRecoverValueTableMastersResult

result = client.describeRecoverValueTableMasters(
    DescribeRecoverValueTableMastersRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復量テーブルマスターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[RecoverValueTableMaster] スタミナ回復量テーブルマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeStaminaModelMasters

同期処理

from gs2_stamina_client.request import DescribeStaminaModelMastersRequest
from gs2_stamina_client.result import DescribeStaminaModelMastersResult

result = client.describe_stamina_model_masters(
    DescribeStaminaModelMastersRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeStaminaModelMastersRequest
import io.gs2.stamina.result.DescribeStaminaModelMastersResult

result = client.describeStaminaModelMasters(
    DescribeStaminaModelMastersRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeStaminaModelMastersRequest
from gs2_stamina_client.result import DescribeStaminaModelMastersResult

def callback(async_result: AsyncResult[DescribeStaminaModelMastersResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_stamina_model_masters_async(
    DescribeStaminaModelMastersRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.DescribeStaminaModelMastersRequest
import io.gs2.stamina.result.DescribeStaminaModelMastersResult

result = client.describeStaminaModelMasters(
    DescribeStaminaModelMastersRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナモデルマスターの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[StaminaModelMaster] スタミナモデルマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeStaminaModels

同期処理

from gs2_stamina_client.request import DescribeStaminaModelsRequest
from gs2_stamina_client.result import DescribeStaminaModelsResult

result = client.describe_stamina_models(
    DescribeStaminaModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeStaminaModelsRequest
import io.gs2.stamina.result.DescribeStaminaModelsResult

result = client.describeStaminaModels(
    DescribeStaminaModelsRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeStaminaModelsRequest
from gs2_stamina_client.result import DescribeStaminaModelsResult

def callback(async_result: AsyncResult[DescribeStaminaModelsResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_stamina_models_async(
    DescribeStaminaModelsRequest()\
    callback
)
import io.gs2.stamina.request.DescribeStaminaModelsRequest
import io.gs2.stamina.result.DescribeStaminaModelsResult

result = client.describeStaminaModels(
    DescribeStaminaModelsRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナモデルの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[StaminaModel] スタミナモデルのリスト

describeStaminas

同期処理

from gs2_stamina_client.request import DescribeStaminasRequest
from gs2_stamina_client.result import DescribeStaminasResult

result = client.describe_staminas(
    DescribeStaminasRequest()\
        .with_namespace_name('namespace-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeStaminasRequest
import io.gs2.stamina.result.DescribeStaminasResult

result = client.describeStaminas(
    DescribeStaminasRequest()
        .withNamespaceName("namespace-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeStaminasRequest
from gs2_stamina_client.result import DescribeStaminasResult

def callback(async_result: AsyncResult[DescribeStaminasResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_staminas_async(
    DescribeStaminasRequest()\
        .with_namespace_name('namespace-0002'),
    callback
)
import io.gs2.stamina.request.DescribeStaminasRequest
import io.gs2.stamina.result.DescribeStaminasResult

result = client.describeStaminas(
    DescribeStaminasRequest()
        .withNamespaceName("namespace-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Stamina] スタミナのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeStaminasByUserId

同期処理

from gs2_stamina_client.request import DescribeStaminasByUserIdRequest
from gs2_stamina_client.result import DescribeStaminasByUserIdResult

result = client.describe_staminas_by_user_id(
    DescribeStaminasByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.DescribeStaminasByUserIdRequest
import io.gs2.stamina.result.DescribeStaminasByUserIdResult

result = client.describeStaminasByUserId(
    DescribeStaminasByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import DescribeStaminasByUserIdRequest
from gs2_stamina_client.result import DescribeStaminasByUserIdResult

def callback(async_result: AsyncResult[DescribeStaminasByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.describe_staminas_by_user_id_async(
    DescribeStaminasByUserIdRequest()\
        .with_namespace_name('namespace-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.stamina.request.DescribeStaminasByUserIdRequest
import io.gs2.stamina.result.DescribeStaminasByUserIdResult

result = client.describeStaminasByUserId(
    DescribeStaminasByUserIdRequest()
        .withNamespaceName("namespace-0002")
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
pageToken string false データの取得を開始する位置を指定するトークン
limit long false データの取得件数
パラメータ データ型 説明
items list[Stamina] スタミナのリスト
nextPageToken string リストの続きを取得するためのページトークン

exportMaster

同期処理

from gs2_stamina_client.request import ExportMasterRequest
from gs2_stamina_client.result import ExportMasterResult

result = client.export_master(
    ExportMasterRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.ExportMasterRequest
import io.gs2.stamina.result.ExportMasterResult

result = client.exportMaster(
    ExportMasterRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import ExportMasterRequest
from gs2_stamina_client.result import ExportMasterResult

def callback(async_result: AsyncResult[ExportMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.export_master_async(
    ExportMasterRequest()\
    callback
)
import io.gs2.stamina.request.ExportMasterRequest
import io.gs2.stamina.result.ExportMasterResult

result = client.exportMaster(
    ExportMasterRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

現在有効なスタミナマスターのマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentStaminaMaster 現在有効なスタミナマスター

getCurrentStaminaMaster

同期処理

from gs2_stamina_client.request import GetCurrentStaminaMasterRequest
from gs2_stamina_client.result import GetCurrentStaminaMasterResult

result = client.get_current_stamina_master(
    GetCurrentStaminaMasterRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetCurrentStaminaMasterRequest
import io.gs2.stamina.result.GetCurrentStaminaMasterResult

result = client.getCurrentStaminaMaster(
    GetCurrentStaminaMasterRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetCurrentStaminaMasterRequest
from gs2_stamina_client.result import GetCurrentStaminaMasterResult

def callback(async_result: AsyncResult[GetCurrentStaminaMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_current_stamina_master_async(
    GetCurrentStaminaMasterRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.GetCurrentStaminaMasterRequest
import io.gs2.stamina.result.GetCurrentStaminaMasterResult

result = client.getCurrentStaminaMaster(
    GetCurrentStaminaMasterRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

現在有効なスタミナマスターを取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentStaminaMaster 現在有効なスタミナマスター

getMaxStaminaTableMaster

同期処理

from gs2_stamina_client.request import GetMaxStaminaTableMasterRequest
from gs2_stamina_client.result import GetMaxStaminaTableMasterResult

result = client.get_max_stamina_table_master(
    GetMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_max_stamina_table_name('max-stamina-table-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetMaxStaminaTableMasterRequest
import io.gs2.stamina.result.GetMaxStaminaTableMasterResult

result = client.getMaxStaminaTableMaster(
    GetMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withMaxStaminaTableName("max-stamina-table-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetMaxStaminaTableMasterRequest
from gs2_stamina_client.result import GetMaxStaminaTableMasterResult

def callback(async_result: AsyncResult[GetMaxStaminaTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_max_stamina_table_master_async(
    GetMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_max_stamina_table_name('max-stamina-table-0001'),
    callback
)
import io.gs2.stamina.request.GetMaxStaminaTableMasterRequest
import io.gs2.stamina.result.GetMaxStaminaTableMasterResult

result = client.getMaxStaminaTableMaster(
    GetMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withMaxStaminaTableName("max-stamina-table-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値テーブルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
maxStaminaTableName string true 最大スタミナ値テーブル名
パラメータ データ型 説明
item MaxStaminaTableMaster スタミナの最大値テーブルマスター

getNamespace

同期処理

from gs2_stamina_client.request import GetNamespaceRequest
from gs2_stamina_client.result import GetNamespaceResult

result = client.get_namespace(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetNamespaceRequest
import io.gs2.stamina.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("namespace-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetNamespaceRequest
from gs2_stamina_client.result import GetNamespaceResult

def callback(async_result: AsyncResult[GetNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_async(
    GetNamespaceRequest()\
        .with_namespace_name('namespace-0001'),
    callback
)
import io.gs2.stamina.request.GetNamespaceRequest
import io.gs2.stamina.result.GetNamespaceResult

result = client.getNamespace(
    GetNamespaceRequest()
        .withNamespaceName("namespace-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item Namespace ネームスペース

getNamespaceStatus

同期処理

from gs2_stamina_client.request import GetNamespaceStatusRequest
from gs2_stamina_client.result import GetNamespaceStatusResult

result = client.get_namespace_status(
    GetNamespaceStatusRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetNamespaceStatusRequest
import io.gs2.stamina.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetNamespaceStatusRequest
from gs2_stamina_client.result import GetNamespaceStatusResult

def callback(async_result: AsyncResult[GetNamespaceStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_namespace_status_async(
    GetNamespaceStatusRequest()\
    callback
)
import io.gs2.stamina.request.GetNamespaceStatusRequest
import io.gs2.stamina.result.GetNamespaceStatusResult

result = client.getNamespaceStatus(
    GetNamespaceStatusRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースの状態を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
status string

getRecoverIntervalTableMaster

同期処理

from gs2_stamina_client.request import GetRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import GetRecoverIntervalTableMasterResult

result = client.get_recover_interval_table_master(
    GetRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_interval_table_name('recover-interval-table-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.GetRecoverIntervalTableMasterResult

result = client.getRecoverIntervalTableMaster(
    GetRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverIntervalTableName("recover-interval-table-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import GetRecoverIntervalTableMasterResult

def callback(async_result: AsyncResult[GetRecoverIntervalTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_recover_interval_table_master_async(
    GetRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_interval_table_name('recover-interval-table-0001'),
    callback
)
import io.gs2.stamina.request.GetRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.GetRecoverIntervalTableMasterResult

result = client.getRecoverIntervalTableMaster(
    GetRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverIntervalTableName("recover-interval-table-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復間隔テーブルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
recoverIntervalTableName string true スタミナ回復間隔テーブル名
パラメータ データ型 説明
item RecoverIntervalTableMaster スタミナ回復間隔テーブルマスター

getRecoverValueTableMaster

同期処理

from gs2_stamina_client.request import GetRecoverValueTableMasterRequest
from gs2_stamina_client.result import GetRecoverValueTableMasterResult

result = client.get_recover_value_table_master(
    GetRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_value_table_name('recover-value-table-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetRecoverValueTableMasterRequest
import io.gs2.stamina.result.GetRecoverValueTableMasterResult

result = client.getRecoverValueTableMaster(
    GetRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverValueTableName("recover-value-table-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetRecoverValueTableMasterRequest
from gs2_stamina_client.result import GetRecoverValueTableMasterResult

def callback(async_result: AsyncResult[GetRecoverValueTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_recover_value_table_master_async(
    GetRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_value_table_name('recover-value-table-0001'),
    callback
)
import io.gs2.stamina.request.GetRecoverValueTableMasterRequest
import io.gs2.stamina.result.GetRecoverValueTableMasterResult

result = client.getRecoverValueTableMaster(
    GetRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverValueTableName("recover-value-table-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復量テーブルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
recoverValueTableName string true スタミナ回復量テーブル名
パラメータ データ型 説明
item RecoverValueTableMaster スタミナ回復量テーブルマスター

getStamina

同期処理

from gs2_stamina_client.request import GetStaminaRequest
from gs2_stamina_client.result import GetStaminaResult

result = client.get_stamina(
    GetStaminaRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetStaminaRequest
import io.gs2.stamina.result.GetStaminaResult

result = client.getStamina(
    GetStaminaRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetStaminaRequest
from gs2_stamina_client.result import GetStaminaResult

def callback(async_result: AsyncResult[GetStaminaResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_stamina_async(
    GetStaminaRequest()\
        .with_namespace_name('namespace-0002')\
        .with_stamina_name('stamina-0001'),
    callback
)
import io.gs2.stamina.request.GetStaminaRequest
import io.gs2.stamina.result.GetStaminaResult

result = client.getStamina(
    GetStaminaRequest()
        .withNamespaceName("namespace-0002")
        .withStaminaName("stamina-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
パラメータ データ型 説明
item Stamina スタミナ

getStaminaByUserId

同期処理

from gs2_stamina_client.request import GetStaminaByUserIdRequest
from gs2_stamina_client.result import GetStaminaByUserIdResult

result = client.get_stamina_by_user_id(
    GetStaminaByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetStaminaByUserIdRequest
import io.gs2.stamina.result.GetStaminaByUserIdResult

result = client.getStaminaByUserId(
    GetStaminaByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001")
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetStaminaByUserIdRequest
from gs2_stamina_client.result import GetStaminaByUserIdResult

def callback(async_result: AsyncResult[GetStaminaByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_stamina_by_user_id_async(
    GetStaminaByUserIdRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.stamina.request.GetStaminaByUserIdRequest
import io.gs2.stamina.result.GetStaminaByUserIdResult

result = client.getStaminaByUserId(
    GetStaminaByUserIdRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001")
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
パラメータ データ型 説明
item Stamina スタミナ

getStaminaModel

同期処理

from gs2_stamina_client.request import GetStaminaModelRequest
from gs2_stamina_client.result import GetStaminaModelResult

result = client.get_stamina_model(
    GetStaminaModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetStaminaModelRequest
import io.gs2.stamina.result.GetStaminaModelResult

result = client.getStaminaModel(
    GetStaminaModelRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetStaminaModelRequest
from gs2_stamina_client.result import GetStaminaModelResult

def callback(async_result: AsyncResult[GetStaminaModelResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_stamina_model_async(
    GetStaminaModelRequest()\
    callback
)
import io.gs2.stamina.request.GetStaminaModelRequest
import io.gs2.stamina.result.GetStaminaModelResult

result = client.getStaminaModel(
    GetStaminaModelRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナモデルを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
パラメータ データ型 説明
item StaminaModel スタミナモデル

getStaminaModelMaster

同期処理

from gs2_stamina_client.request import GetStaminaModelMasterRequest
from gs2_stamina_client.result import GetStaminaModelMasterResult

result = client.get_stamina_model_master(
    GetStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.GetStaminaModelMasterRequest
import io.gs2.stamina.result.GetStaminaModelMasterResult

result = client.getStaminaModelMaster(
    GetStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import GetStaminaModelMasterRequest
from gs2_stamina_client.result import GetStaminaModelMasterResult

def callback(async_result: AsyncResult[GetStaminaModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.get_stamina_model_master_async(
    GetStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001'),
    callback
)
import io.gs2.stamina.request.GetStaminaModelMasterRequest
import io.gs2.stamina.result.GetStaminaModelMasterResult

result = client.getStaminaModelMaster(
    GetStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナモデルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
パラメータ データ型 説明
item StaminaModelMaster スタミナモデルマスター

raiseMaxValueByStampSheet

同期処理

from gs2_stamina_client.request import RaiseMaxValueByStampSheetRequest
from gs2_stamina_client.result import RaiseMaxValueByStampSheetResult

result = client.raise_max_value_by_stamp_sheet(
    RaiseMaxValueByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.RaiseMaxValueByStampSheetRequest
import io.gs2.stamina.result.RaiseMaxValueByStampSheetResult

result = client.raiseMaxValueByStampSheet(
    RaiseMaxValueByStampSheetRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import RaiseMaxValueByStampSheetRequest
from gs2_stamina_client.result import RaiseMaxValueByStampSheetResult

def callback(async_result: AsyncResult[RaiseMaxValueByStampSheetResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.raise_max_value_by_stamp_sheet_async(
    RaiseMaxValueByStampSheetRequest()\
    callback
)
import io.gs2.stamina.request.RaiseMaxValueByStampSheetRequest
import io.gs2.stamina.result.RaiseMaxValueByStampSheetResult

result = client.raiseMaxValueByStampSheet(
    RaiseMaxValueByStampSheetRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートでスタミナの最大値を加算

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Stamina スタミナ

raiseMaxValueByUserId

同期処理

from gs2_stamina_client.request import RaiseMaxValueByUserIdRequest
from gs2_stamina_client.result import RaiseMaxValueByUserIdResult

result = client.raise_max_value_by_user_id(
    RaiseMaxValueByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.RaiseMaxValueByUserIdRequest
import io.gs2.stamina.result.RaiseMaxValueByUserIdResult

result = client.raiseMaxValueByUserId(
    RaiseMaxValueByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import RaiseMaxValueByUserIdRequest
from gs2_stamina_client.result import RaiseMaxValueByUserIdResult

def callback(async_result: AsyncResult[RaiseMaxValueByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.raise_max_value_by_user_id_async(
    RaiseMaxValueByUserIdRequest()\
    callback
)
import io.gs2.stamina.request.RaiseMaxValueByUserIdRequest
import io.gs2.stamina.result.RaiseMaxValueByUserIdResult

result = client.raiseMaxValueByUserId(
    RaiseMaxValueByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナの最大値を加算

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
raiseValue integer true 上昇する最大スタミナ量
パラメータ データ型 説明
item Stamina スタミナ

recoverStaminaByStampSheet

同期処理

from gs2_stamina_client.request import RecoverStaminaByStampSheetRequest
from gs2_stamina_client.result import RecoverStaminaByStampSheetResult

result = client.recover_stamina_by_stamp_sheet(
    RecoverStaminaByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.RecoverStaminaByStampSheetRequest
import io.gs2.stamina.result.RecoverStaminaByStampSheetResult

result = client.recoverStaminaByStampSheet(
    RecoverStaminaByStampSheetRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import RecoverStaminaByStampSheetRequest
from gs2_stamina_client.result import RecoverStaminaByStampSheetResult

def callback(async_result: AsyncResult[RecoverStaminaByStampSheetResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.recover_stamina_by_stamp_sheet_async(
    RecoverStaminaByStampSheetRequest()\
    callback
)
import io.gs2.stamina.request.RecoverStaminaByStampSheetRequest
import io.gs2.stamina.result.RecoverStaminaByStampSheetResult

result = client.recoverStaminaByStampSheet(
    RecoverStaminaByStampSheetRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートを使用してスタミナを回復

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Stamina スタミナ
overflowValue long スタミナ値の上限を超えて受け取れずに GS2-Inbox に転送したスタミナ値

recoverStaminaByUserId

同期処理

from gs2_stamina_client.request import RecoverStaminaByUserIdRequest
from gs2_stamina_client.result import RecoverStaminaByUserIdResult

result = client.recover_stamina_by_user_id(
    RecoverStaminaByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.RecoverStaminaByUserIdRequest
import io.gs2.stamina.result.RecoverStaminaByUserIdResult

result = client.recoverStaminaByUserId(
    RecoverStaminaByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import RecoverStaminaByUserIdRequest
from gs2_stamina_client.result import RecoverStaminaByUserIdResult

def callback(async_result: AsyncResult[RecoverStaminaByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.recover_stamina_by_user_id_async(
    RecoverStaminaByUserIdRequest()\
    callback
)
import io.gs2.stamina.request.RecoverStaminaByUserIdRequest
import io.gs2.stamina.result.RecoverStaminaByUserIdResult

result = client.recoverStaminaByUserId(
    RecoverStaminaByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナを回復

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
recoverValue integer true 回復するスタミナ量
パラメータ データ型 説明
item Stamina スタミナ
overflowValue long スタミナ値の上限を超えて受け取れずに GS2-Inbox に転送したスタミナ値

setMaxValueByStampSheet

同期処理

from gs2_stamina_client.request import SetMaxValueByStampSheetRequest
from gs2_stamina_client.result import SetMaxValueByStampSheetResult

result = client.set_max_value_by_stamp_sheet(
    SetMaxValueByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetMaxValueByStampSheetRequest
import io.gs2.stamina.result.SetMaxValueByStampSheetResult

result = client.setMaxValueByStampSheet(
    SetMaxValueByStampSheetRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetMaxValueByStampSheetRequest
from gs2_stamina_client.result import SetMaxValueByStampSheetResult

def callback(async_result: AsyncResult[SetMaxValueByStampSheetResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_max_value_by_stamp_sheet_async(
    SetMaxValueByStampSheetRequest()\
    callback
)
import io.gs2.stamina.request.SetMaxValueByStampSheetRequest
import io.gs2.stamina.result.SetMaxValueByStampSheetResult

result = client.setMaxValueByStampSheet(
    SetMaxValueByStampSheetRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートでスタミナの最大値を更新

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Stamina スタミナ

setMaxValueByStatus

同期処理

from gs2_stamina_client.request import SetMaxValueByStatusRequest
from gs2_stamina_client.result import SetMaxValueByStatusResult

result = client.set_max_value_by_status(
    SetMaxValueByStatusRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetMaxValueByStatusRequest
import io.gs2.stamina.result.SetMaxValueByStatusResult

result = client.setMaxValueByStatus(
    SetMaxValueByStatusRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetMaxValueByStatusRequest
from gs2_stamina_client.result import SetMaxValueByStatusResult

def callback(async_result: AsyncResult[SetMaxValueByStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_max_value_by_status_async(
    SetMaxValueByStatusRequest()\
    callback
)
import io.gs2.stamina.request.SetMaxValueByStatusRequest
import io.gs2.stamina.result.SetMaxValueByStatusResult

result = client.setMaxValueByStatus(
    SetMaxValueByStatusRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値をGS2-Experienceのステータスを使用して更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
keyId string true 署名をつけるのに使用した暗号鍵 のGRN
signedStatusBody string true 署名対象のステータスボディ
signedStatusSignature string true ステータスの署名
パラメータ データ型 説明
item Stamina スタミナ

setMaxValueByUserId

同期処理

from gs2_stamina_client.request import SetMaxValueByUserIdRequest
from gs2_stamina_client.result import SetMaxValueByUserIdResult

result = client.set_max_value_by_user_id(
    SetMaxValueByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetMaxValueByUserIdRequest
import io.gs2.stamina.result.SetMaxValueByUserIdResult

result = client.setMaxValueByUserId(
    SetMaxValueByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetMaxValueByUserIdRequest
from gs2_stamina_client.result import SetMaxValueByUserIdResult

def callback(async_result: AsyncResult[SetMaxValueByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_max_value_by_user_id_async(
    SetMaxValueByUserIdRequest()\
    callback
)
import io.gs2.stamina.request.SetMaxValueByUserIdRequest
import io.gs2.stamina.result.SetMaxValueByUserIdResult

result = client.setMaxValueByUserId(
    SetMaxValueByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナの最大値を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
maxValue integer true スタミナの最大値
パラメータ データ型 説明
item Stamina スタミナ

setRecoverIntervalByStampSheet

同期処理

from gs2_stamina_client.request import SetRecoverIntervalByStampSheetRequest
from gs2_stamina_client.result import SetRecoverIntervalByStampSheetResult

result = client.set_recover_interval_by_stamp_sheet(
    SetRecoverIntervalByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetRecoverIntervalByStampSheetRequest
import io.gs2.stamina.result.SetRecoverIntervalByStampSheetResult

result = client.setRecoverIntervalByStampSheet(
    SetRecoverIntervalByStampSheetRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetRecoverIntervalByStampSheetRequest
from gs2_stamina_client.result import SetRecoverIntervalByStampSheetResult

def callback(async_result: AsyncResult[SetRecoverIntervalByStampSheetResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_recover_interval_by_stamp_sheet_async(
    SetRecoverIntervalByStampSheetRequest()\
    callback
)
import io.gs2.stamina.request.SetRecoverIntervalByStampSheetRequest
import io.gs2.stamina.result.SetRecoverIntervalByStampSheetResult

result = client.setRecoverIntervalByStampSheet(
    SetRecoverIntervalByStampSheetRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートでスタミナの最大値を更新

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Stamina スタミナ

setRecoverIntervalByStatus

同期処理

from gs2_stamina_client.request import SetRecoverIntervalByStatusRequest
from gs2_stamina_client.result import SetRecoverIntervalByStatusResult

result = client.set_recover_interval_by_status(
    SetRecoverIntervalByStatusRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetRecoverIntervalByStatusRequest
import io.gs2.stamina.result.SetRecoverIntervalByStatusResult

result = client.setRecoverIntervalByStatus(
    SetRecoverIntervalByStatusRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetRecoverIntervalByStatusRequest
from gs2_stamina_client.result import SetRecoverIntervalByStatusResult

def callback(async_result: AsyncResult[SetRecoverIntervalByStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_recover_interval_by_status_async(
    SetRecoverIntervalByStatusRequest()\
    callback
)
import io.gs2.stamina.request.SetRecoverIntervalByStatusRequest
import io.gs2.stamina.result.SetRecoverIntervalByStatusResult

result = client.setRecoverIntervalByStatus(
    SetRecoverIntervalByStatusRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値をGS2-Experienceのステータスを使用して更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
keyId string true 署名をつけるのに使用した暗号鍵 のGRN
signedStatusBody string true 署名対象のステータスボディ
signedStatusSignature string true ステータスの署名
パラメータ データ型 説明
item Stamina スタミナ

setRecoverIntervalByUserId

同期処理

from gs2_stamina_client.request import SetRecoverIntervalByUserIdRequest
from gs2_stamina_client.result import SetRecoverIntervalByUserIdResult

result = client.set_recover_interval_by_user_id(
    SetRecoverIntervalByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetRecoverIntervalByUserIdRequest
import io.gs2.stamina.result.SetRecoverIntervalByUserIdResult

result = client.setRecoverIntervalByUserId(
    SetRecoverIntervalByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetRecoverIntervalByUserIdRequest
from gs2_stamina_client.result import SetRecoverIntervalByUserIdResult

def callback(async_result: AsyncResult[SetRecoverIntervalByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_recover_interval_by_user_id_async(
    SetRecoverIntervalByUserIdRequest()\
    callback
)
import io.gs2.stamina.request.SetRecoverIntervalByUserIdRequest
import io.gs2.stamina.result.SetRecoverIntervalByUserIdResult

result = client.setRecoverIntervalByUserId(
    SetRecoverIntervalByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナの回復間隔(分)を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
recoverIntervalMinutes integer false スタミナの回復間隔(分)
パラメータ データ型 説明
item Stamina スタミナ

setRecoverValueByStampSheet

同期処理

from gs2_stamina_client.request import SetRecoverValueByStampSheetRequest
from gs2_stamina_client.result import SetRecoverValueByStampSheetResult

result = client.set_recover_value_by_stamp_sheet(
    SetRecoverValueByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetRecoverValueByStampSheetRequest
import io.gs2.stamina.result.SetRecoverValueByStampSheetResult

result = client.setRecoverValueByStampSheet(
    SetRecoverValueByStampSheetRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetRecoverValueByStampSheetRequest
from gs2_stamina_client.result import SetRecoverValueByStampSheetResult

def callback(async_result: AsyncResult[SetRecoverValueByStampSheetResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_recover_value_by_stamp_sheet_async(
    SetRecoverValueByStampSheetRequest()\
    callback
)
import io.gs2.stamina.request.SetRecoverValueByStampSheetRequest
import io.gs2.stamina.result.SetRecoverValueByStampSheetResult

result = client.setRecoverValueByStampSheet(
    SetRecoverValueByStampSheetRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタンプシートでスタミナの最大値を更新

パラメータ データ型 必須 説明
stampSheet string true スタンプシート
keyId string true スタンプシートの署名検証に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Stamina スタミナ

setRecoverValueByStatus

同期処理

from gs2_stamina_client.request import SetRecoverValueByStatusRequest
from gs2_stamina_client.result import SetRecoverValueByStatusResult

result = client.set_recover_value_by_status(
    SetRecoverValueByStatusRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetRecoverValueByStatusRequest
import io.gs2.stamina.result.SetRecoverValueByStatusResult

result = client.setRecoverValueByStatus(
    SetRecoverValueByStatusRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetRecoverValueByStatusRequest
from gs2_stamina_client.result import SetRecoverValueByStatusResult

def callback(async_result: AsyncResult[SetRecoverValueByStatusResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_recover_value_by_status_async(
    SetRecoverValueByStatusRequest()\
    callback
)
import io.gs2.stamina.request.SetRecoverValueByStatusRequest
import io.gs2.stamina.result.SetRecoverValueByStatusResult

result = client.setRecoverValueByStatus(
    SetRecoverValueByStatusRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値をGS2-Experienceのステータスを使用して更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
keyId string true 署名をつけるのに使用した暗号鍵 のGRN
signedStatusBody string true 署名対象のステータスボディ
signedStatusSignature string true ステータスの署名
パラメータ データ型 説明
item Stamina スタミナ

setRecoverValueByUserId

同期処理

from gs2_stamina_client.request import SetRecoverValueByUserIdRequest
from gs2_stamina_client.result import SetRecoverValueByUserIdResult

result = client.set_recover_value_by_user_id(
    SetRecoverValueByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.SetRecoverValueByUserIdRequest
import io.gs2.stamina.result.SetRecoverValueByUserIdResult

result = client.setRecoverValueByUserId(
    SetRecoverValueByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import SetRecoverValueByUserIdRequest
from gs2_stamina_client.result import SetRecoverValueByUserIdResult

def callback(async_result: AsyncResult[SetRecoverValueByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.set_recover_value_by_user_id_async(
    SetRecoverValueByUserIdRequest()\
    callback
)
import io.gs2.stamina.request.SetRecoverValueByUserIdRequest
import io.gs2.stamina.result.SetRecoverValueByUserIdResult

result = client.setRecoverValueByUserId(
    SetRecoverValueByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナの回復間隔(分)を更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
recoverValue integer false スタミナの回復量
パラメータ データ型 説明
item Stamina スタミナ

updateCurrentStaminaMaster

同期処理

from gs2_stamina_client.request import UpdateCurrentStaminaMasterRequest
from gs2_stamina_client.result import UpdateCurrentStaminaMasterResult

result = client.update_current_stamina_master(
    UpdateCurrentStaminaMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-02-14",\n  "staminaModels": [\n    {\n      "name": "quest",\n      "metadata": "QUEST",\n      "recoverIntervalMinutes": 15,\n      "recoverValue": 1,\n      "initialCapacity": 50,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "playerLevel",\n        "metadata": "PLAYER_LEVEL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119,\n          120,\n          121,\n          122,\n          123,\n          124,\n          125,\n          126,\n          127,\n          128,\n          129\n        ]\n      },\n      "recoverIntervalTable": {\n        "name": "staminaRecoverInterval",\n        "metadata": "STAMINA_RECOVER_INTERVAL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119\n        ]\n      },\n      "recoverValueTable": {\n        "name": "staminaRecoverValue",\n        "metadata": "STAMINA_RECOVER_VALUE",\n        "experienceModelId": "playerLevel",\n        "values": [\n          31,\n          32,\n          33,\n          34,\n          35,\n          36,\n          37,\n          38,\n          39,\n          40,\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109\n        ]\n      }\n    },\n    {\n      "name": "raidBattle",\n      "metadata": "RAID_BATTLE",\n      "recoverIntervalMinutes": 60,\n      "recoverValue": 1,\n      "initialCapacity": 10,\n      "isOverflow": false\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "recoverIntervalMinutes": 30,\n      "recoverValue": 3,\n      "initialCapacity": 100,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "special",\n        "metadata": "SPECIAL",\n        "experienceModelId": "special",\n        "values": [\n          102,\n          104,\n          106,\n          108,\n          110,\n          112,\n          114,\n          116,\n          118,\n          120,\n          122,\n          124,\n          126,\n          128,\n          130,\n          132,\n          134,\n          136,\n          138,\n          140,\n          142,\n          144,\n          146,\n          148,\n          150,\n          152,\n          154,\n          156,\n          158,\n          160,\n          162,\n          164,\n          166,\n          168,\n          170,\n          172,\n          174,\n          176,\n          178,\n          180,\n          182,\n          184,\n          186,\n          188,\n          190,\n          192,\n          194,\n          196,\n          198,\n          200,\n          202,\n          204,\n          206,\n          208,\n          210,\n          212,\n          214,\n          216,\n          218,\n          220,\n          222,\n          224,\n          226,\n          228,\n          230,\n          232,\n          234,\n          236,\n          238,\n          240,\n          242,\n          244,\n          246,\n          248,\n          250,\n          252,\n          254,\n          256,\n          258\n        ]\n      }\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateCurrentStaminaMasterRequest
import io.gs2.stamina.result.UpdateCurrentStaminaMasterResult

result = client.updateCurrentStaminaMaster(
    UpdateCurrentStaminaMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-02-14",\n  "staminaModels": [\n    {\n      "name": "quest",\n      "metadata": "QUEST",\n      "recoverIntervalMinutes": 15,\n      "recoverValue": 1,\n      "initialCapacity": 50,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "playerLevel",\n        "metadata": "PLAYER_LEVEL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119,\n          120,\n          121,\n          122,\n          123,\n          124,\n          125,\n          126,\n          127,\n          128,\n          129\n        ]\n      },\n      "recoverIntervalTable": {\n        "name": "staminaRecoverInterval",\n        "metadata": "STAMINA_RECOVER_INTERVAL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119\n        ]\n      },\n      "recoverValueTable": {\n        "name": "staminaRecoverValue",\n        "metadata": "STAMINA_RECOVER_VALUE",\n        "experienceModelId": "playerLevel",\n        "values": [\n          31,\n          32,\n          33,\n          34,\n          35,\n          36,\n          37,\n          38,\n          39,\n          40,\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109\n        ]\n      }\n    },\n    {\n      "name": "raidBattle",\n      "metadata": "RAID_BATTLE",\n      "recoverIntervalMinutes": 60,\n      "recoverValue": 1,\n      "initialCapacity": 10,\n      "isOverflow": false\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "recoverIntervalMinutes": 30,\n      "recoverValue": 3,\n      "initialCapacity": 100,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "special",\n        "metadata": "SPECIAL",\n        "experienceModelId": "special",\n        "values": [\n          102,\n          104,\n          106,\n          108,\n          110,\n          112,\n          114,\n          116,\n          118,\n          120,\n          122,\n          124,\n          126,\n          128,\n          130,\n          132,\n          134,\n          136,\n          138,\n          140,\n          142,\n          144,\n          146,\n          148,\n          150,\n          152,\n          154,\n          156,\n          158,\n          160,\n          162,\n          164,\n          166,\n          168,\n          170,\n          172,\n          174,\n          176,\n          178,\n          180,\n          182,\n          184,\n          186,\n          188,\n          190,\n          192,\n          194,\n          196,\n          198,\n          200,\n          202,\n          204,\n          206,\n          208,\n          210,\n          212,\n          214,\n          216,\n          218,\n          220,\n          222,\n          224,\n          226,\n          228,\n          230,\n          232,\n          234,\n          236,\n          238,\n          240,\n          242,\n          244,\n          246,\n          248,\n          250,\n          252,\n          254,\n          256,\n          258\n        ]\n      }\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateCurrentStaminaMasterRequest
from gs2_stamina_client.result import UpdateCurrentStaminaMasterResult

def callback(async_result: AsyncResult[UpdateCurrentStaminaMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_current_stamina_master_async(
    UpdateCurrentStaminaMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_settings('{\n  "version": "2019-02-14",\n  "staminaModels": [\n    {\n      "name": "quest",\n      "metadata": "QUEST",\n      "recoverIntervalMinutes": 15,\n      "recoverValue": 1,\n      "initialCapacity": 50,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "playerLevel",\n        "metadata": "PLAYER_LEVEL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119,\n          120,\n          121,\n          122,\n          123,\n          124,\n          125,\n          126,\n          127,\n          128,\n          129\n        ]\n      },\n      "recoverIntervalTable": {\n        "name": "staminaRecoverInterval",\n        "metadata": "STAMINA_RECOVER_INTERVAL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119\n        ]\n      },\n      "recoverValueTable": {\n        "name": "staminaRecoverValue",\n        "metadata": "STAMINA_RECOVER_VALUE",\n        "experienceModelId": "playerLevel",\n        "values": [\n          31,\n          32,\n          33,\n          34,\n          35,\n          36,\n          37,\n          38,\n          39,\n          40,\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109\n        ]\n      }\n    },\n    {\n      "name": "raidBattle",\n      "metadata": "RAID_BATTLE",\n      "recoverIntervalMinutes": 60,\n      "recoverValue": 1,\n      "initialCapacity": 10,\n      "isOverflow": false\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "recoverIntervalMinutes": 30,\n      "recoverValue": 3,\n      "initialCapacity": 100,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "special",\n        "metadata": "SPECIAL",\n        "experienceModelId": "special",\n        "values": [\n          102,\n          104,\n          106,\n          108,\n          110,\n          112,\n          114,\n          116,\n          118,\n          120,\n          122,\n          124,\n          126,\n          128,\n          130,\n          132,\n          134,\n          136,\n          138,\n          140,\n          142,\n          144,\n          146,\n          148,\n          150,\n          152,\n          154,\n          156,\n          158,\n          160,\n          162,\n          164,\n          166,\n          168,\n          170,\n          172,\n          174,\n          176,\n          178,\n          180,\n          182,\n          184,\n          186,\n          188,\n          190,\n          192,\n          194,\n          196,\n          198,\n          200,\n          202,\n          204,\n          206,\n          208,\n          210,\n          212,\n          214,\n          216,\n          218,\n          220,\n          222,\n          224,\n          226,\n          228,\n          230,\n          232,\n          234,\n          236,\n          238,\n          240,\n          242,\n          244,\n          246,\n          248,\n          250,\n          252,\n          254,\n          256,\n          258\n        ]\n      }\n    }\n  ]\n}'),
    callback
)
import io.gs2.stamina.request.UpdateCurrentStaminaMasterRequest
import io.gs2.stamina.result.UpdateCurrentStaminaMasterResult

result = client.updateCurrentStaminaMaster(
    UpdateCurrentStaminaMasterRequest()
        .withNamespaceName("namespace-0001")
        .withSettings("{\n  "version": "2019-02-14",\n  "staminaModels": [\n    {\n      "name": "quest",\n      "metadata": "QUEST",\n      "recoverIntervalMinutes": 15,\n      "recoverValue": 1,\n      "initialCapacity": 50,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "playerLevel",\n        "metadata": "PLAYER_LEVEL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119,\n          120,\n          121,\n          122,\n          123,\n          124,\n          125,\n          126,\n          127,\n          128,\n          129\n        ]\n      },\n      "recoverIntervalTable": {\n        "name": "staminaRecoverInterval",\n        "metadata": "STAMINA_RECOVER_INTERVAL",\n        "experienceModelId": "playerLevel",\n        "values": [\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109,\n          110,\n          111,\n          112,\n          113,\n          114,\n          115,\n          116,\n          117,\n          118,\n          119\n        ]\n      },\n      "recoverValueTable": {\n        "name": "staminaRecoverValue",\n        "metadata": "STAMINA_RECOVER_VALUE",\n        "experienceModelId": "playerLevel",\n        "values": [\n          31,\n          32,\n          33,\n          34,\n          35,\n          36,\n          37,\n          38,\n          39,\n          40,\n          41,\n          42,\n          43,\n          44,\n          45,\n          46,\n          47,\n          48,\n          49,\n          50,\n          51,\n          52,\n          53,\n          54,\n          55,\n          56,\n          57,\n          58,\n          59,\n          60,\n          61,\n          62,\n          63,\n          64,\n          65,\n          66,\n          67,\n          68,\n          69,\n          70,\n          71,\n          72,\n          73,\n          74,\n          75,\n          76,\n          77,\n          78,\n          79,\n          80,\n          81,\n          82,\n          83,\n          84,\n          85,\n          86,\n          87,\n          88,\n          89,\n          90,\n          91,\n          92,\n          93,\n          94,\n          95,\n          96,\n          97,\n          98,\n          99,\n          100,\n          101,\n          102,\n          103,\n          104,\n          105,\n          106,\n          107,\n          108,\n          109\n        ]\n      }\n    },\n    {\n      "name": "raidBattle",\n      "metadata": "RAID_BATTLE",\n      "recoverIntervalMinutes": 60,\n      "recoverValue": 1,\n      "initialCapacity": 10,\n      "isOverflow": false\n    },\n    {\n      "name": "special",\n      "metadata": "SPECIAL",\n      "recoverIntervalMinutes": 30,\n      "recoverValue": 3,\n      "initialCapacity": 100,\n      "isOverflow": true,\n      "maxCapacity": 999,\n      "maxStaminaTable": {\n        "name": "special",\n        "metadata": "SPECIAL",\n        "experienceModelId": "special",\n        "values": [\n          102,\n          104,\n          106,\n          108,\n          110,\n          112,\n          114,\n          116,\n          118,\n          120,\n          122,\n          124,\n          126,\n          128,\n          130,\n          132,\n          134,\n          136,\n          138,\n          140,\n          142,\n          144,\n          146,\n          148,\n          150,\n          152,\n          154,\n          156,\n          158,\n          160,\n          162,\n          164,\n          166,\n          168,\n          170,\n          172,\n          174,\n          176,\n          178,\n          180,\n          182,\n          184,\n          186,\n          188,\n          190,\n          192,\n          194,\n          196,\n          198,\n          200,\n          202,\n          204,\n          206,\n          208,\n          210,\n          212,\n          214,\n          216,\n          218,\n          220,\n          222,\n          224,\n          226,\n          228,\n          230,\n          232,\n          234,\n          236,\n          238,\n          240,\n          242,\n          244,\n          246,\n          248,\n          250,\n          252,\n          254,\n          256,\n          258\n        ]\n      }\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Stamina::CurrentStaminaMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効なスタミナマスターを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentStaminaMaster 更新した現在有効なスタミナマスター

updateCurrentStaminaMasterFromGitHub

同期処理

from gs2_stamina_client.request import UpdateCurrentStaminaMasterFromGitHubRequest
from gs2_stamina_client.result import UpdateCurrentStaminaMasterFromGitHubResult

result = client.update_current_stamina_master_from_git_hub(
    UpdateCurrentStaminaMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateCurrentStaminaMasterFromGitHubRequest
import io.gs2.stamina.result.UpdateCurrentStaminaMasterFromGitHubResult

result = client.updateCurrentStaminaMasterFromGitHub(
    UpdateCurrentStaminaMasterFromGitHubRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateCurrentStaminaMasterFromGitHubRequest
from gs2_stamina_client.result import UpdateCurrentStaminaMasterFromGitHubResult

def callback(async_result: AsyncResult[UpdateCurrentStaminaMasterFromGitHubResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_current_stamina_master_from_git_hub_async(
    UpdateCurrentStaminaMasterFromGitHubRequest()\
    callback
)
import io.gs2.stamina.request.UpdateCurrentStaminaMasterFromGitHubRequest
import io.gs2.stamina.result.UpdateCurrentStaminaMasterFromGitHubResult

result = client.updateCurrentStaminaMasterFromGitHub(
    UpdateCurrentStaminaMasterFromGitHubRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

現在有効なスタミナマスターを更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
checkoutSetting GitHubCheckoutSetting true GitHubからマスターデータをチェックアウトしてくる設定
パラメータ データ型 説明
item CurrentStaminaMaster 更新した現在有効なスタミナマスター

updateMaxStaminaTableMaster

同期処理

from gs2_stamina_client.request import UpdateMaxStaminaTableMasterRequest
from gs2_stamina_client.result import UpdateMaxStaminaTableMasterResult

result = client.update_max_stamina_table_master(
    UpdateMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_max_stamina_table_name('max-stamina-table-0001')\
        .with_description('description1')\
        .with_experience_model_id('experienceModelId-1001')\
        .with_values([
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateMaxStaminaTableMasterRequest
import io.gs2.stamina.result.UpdateMaxStaminaTableMasterResult

result = client.updateMaxStaminaTableMaster(
    UpdateMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withMaxStaminaTableName("max-stamina-table-0001")
        .withDescription("description1")
        .withExperienceModelId("experienceModelId-1001")
        .withValues(new [] {
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateMaxStaminaTableMasterRequest
from gs2_stamina_client.result import UpdateMaxStaminaTableMasterResult

def callback(async_result: AsyncResult[UpdateMaxStaminaTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_max_stamina_table_master_async(
    UpdateMaxStaminaTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_max_stamina_table_name('max-stamina-table-0001')\
        .with_description('description1')\
        .with_experience_model_id('experienceModelId-1001')\
        .with_values([
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
]),
    callback
)
import io.gs2.stamina.request.UpdateMaxStaminaTableMasterRequest
import io.gs2.stamina.result.UpdateMaxStaminaTableMasterResult

result = client.updateMaxStaminaTableMaster(
    UpdateMaxStaminaTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withMaxStaminaTableName("max-stamina-table-0001")
        .withDescription("description1")
        .withExperienceModelId("experienceModelId-1001")
        .withValues(new [] {
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナの最大値テーブルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
maxStaminaTableName string true 最大スタミナ値テーブル名
description string false スタミナの最大値テーブルマスターの説明
metadata string false 最大スタミナ値テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナの最大値テーブル
パラメータ データ型 説明
item MaxStaminaTableMaster 更新したスタミナの最大値テーブルマスター

updateNamespace

同期処理

from gs2_stamina_client.request import UpdateNamespaceRequest
from gs2_stamina_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateNamespaceRequest
import io.gs2.stamina.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"}))
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateNamespaceRequest
from gs2_stamina_client.result import UpdateNamespaceResult

def callback(async_result: AsyncResult[UpdateNamespaceResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_namespace_async(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespace-0001')\
        .with_description('description1')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.stamina.request.UpdateNamespaceRequest
import io.gs2.stamina.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespace-0001")
        .withDescription("description1")
        .withLogSetting(Object("LogSetting", {"loggingNamespaceId": "grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001"})),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ネームスペースを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
description string false 説明文
overflowTriggerScriptId string false スタミナオーバーフロー上限に当たって回復できなかったスタミナを通知する スクリプト のGRN
overflowTriggerNamespaceId string false スタミナオーバーフロー上限に当たって回復できなかったスタミナを追加する ネームスペース のGRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateRecoverIntervalTableMaster

同期処理

from gs2_stamina_client.request import UpdateRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import UpdateRecoverIntervalTableMasterResult

result = client.update_recover_interval_table_master(
    UpdateRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_interval_table_name('recover-interval-table-0001')\
        .with_description('description1')\
        .with_experience_model_id('experienceModelId-1001')\
        .with_values([
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.UpdateRecoverIntervalTableMasterResult

result = client.updateRecoverIntervalTableMaster(
    UpdateRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverIntervalTableName("recover-interval-table-0001")
        .withDescription("description1")
        .withExperienceModelId("experienceModelId-1001")
        .withValues(new [] {
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateRecoverIntervalTableMasterRequest
from gs2_stamina_client.result import UpdateRecoverIntervalTableMasterResult

def callback(async_result: AsyncResult[UpdateRecoverIntervalTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_recover_interval_table_master_async(
    UpdateRecoverIntervalTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_interval_table_name('recover-interval-table-0001')\
        .with_description('description1')\
        .with_experience_model_id('experienceModelId-1001')\
        .with_values([
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
]),
    callback
)
import io.gs2.stamina.request.UpdateRecoverIntervalTableMasterRequest
import io.gs2.stamina.result.UpdateRecoverIntervalTableMasterResult

result = client.updateRecoverIntervalTableMaster(
    UpdateRecoverIntervalTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverIntervalTableName("recover-interval-table-0001")
        .withDescription("description1")
        .withExperienceModelId("experienceModelId-1001")
        .withValues(new [] {
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復間隔テーブルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
recoverIntervalTableName string true スタミナ回復間隔テーブル名
description string false スタミナ回復間隔テーブルマスターの説明
metadata string false スタミナ回復間隔テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復間隔テーブル
パラメータ データ型 説明
item RecoverIntervalTableMaster 更新したスタミナ回復間隔テーブルマスター

updateRecoverValueTableMaster

同期処理

from gs2_stamina_client.request import UpdateRecoverValueTableMasterRequest
from gs2_stamina_client.result import UpdateRecoverValueTableMasterResult

result = client.update_recover_value_table_master(
    UpdateRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_value_table_name('recover-value-table-0001')\
        .with_description('description1')\
        .with_experience_model_id('experienceModelId-1001')\
        .with_values([
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateRecoverValueTableMasterRequest
import io.gs2.stamina.result.UpdateRecoverValueTableMasterResult

result = client.updateRecoverValueTableMaster(
    UpdateRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverValueTableName("recover-value-table-0001")
        .withDescription("description1")
        .withExperienceModelId("experienceModelId-1001")
        .withValues(new [] {
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateRecoverValueTableMasterRequest
from gs2_stamina_client.result import UpdateRecoverValueTableMasterResult

def callback(async_result: AsyncResult[UpdateRecoverValueTableMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_recover_value_table_master_async(
    UpdateRecoverValueTableMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_recover_value_table_name('recover-value-table-0001')\
        .with_description('description1')\
        .with_experience_model_id('experienceModelId-1001')\
        .with_values([
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
]),
    callback
)
import io.gs2.stamina.request.UpdateRecoverValueTableMasterRequest
import io.gs2.stamina.result.UpdateRecoverValueTableMasterResult

result = client.updateRecoverValueTableMaster(
    UpdateRecoverValueTableMasterRequest()
        .withNamespaceName("namespace-0001")
        .withRecoverValueTableName("recover-value-table-0001")
        .withDescription("description1")
        .withExperienceModelId("experienceModelId-1001")
        .withValues(new [] {
0,  
150,    
300,    
450,    
600,    
750,    
900,    
1050,   
1200,   
1350,   
1500,   
1650,   
1800,   
1950,   
2100,   
2250,   
2400,   
2550,   
2700,   
2850,   
3000,   
3150,   
3300,   
3450,   
3600,   
3750,   
3900,   
4050,   
4200,   
4350,   
4500,   
4650,   
4800,   
4950,   
5100,   
5250,   
5400,   
5550,   
5700,   
5850,   
6000,   
6150,   
6300,   
6450,   
6600,   
6750,   
6900,   
7050,   
7200,   
7350,   
7500,   
7650,   
7800,   
7950,   
8100,   
8250,   
8400,   
8550,   
8700,   
8850,   
9000,   
9150,   
9300,   
9450,   
9600,   
9750,   
9900,   
10050,  
10200,  
10350,  
10500,  
10650,  
10800,  
10950,  
11100,  
11250,  
11400,  
11550,  
11700,  
11850,  
12000,  
12150,  
12300,  
12450,  
12600,  
12750,  
12900,  
13050,  
13200,  
13350,  
13500,  
13650,  
13800,  
13950,  
14100,  
14250,  
14400,  
14550,  
14700,  
14850
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナ回復量テーブルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
recoverValueTableName string true スタミナ回復量テーブル名
description string false スタミナ回復量テーブルマスターの説明
metadata string false スタミナ回復量テーブルのメタデータ
experienceModelId string true 経験値の種類マスター のGRN
values list[integer] true ランク毎のスタミナ回復量テーブル
パラメータ データ型 説明
item RecoverValueTableMaster 更新したスタミナ回復量テーブルマスター

updateStaminaByUserId

同期処理

from gs2_stamina_client.request import UpdateStaminaByUserIdRequest
from gs2_stamina_client.result import UpdateStaminaByUserIdResult

result = client.update_stamina_by_user_id(
    UpdateStaminaByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateStaminaByUserIdRequest
import io.gs2.stamina.result.UpdateStaminaByUserIdResult

result = client.updateStaminaByUserId(
    UpdateStaminaByUserIdRequest()
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateStaminaByUserIdRequest
from gs2_stamina_client.result import UpdateStaminaByUserIdResult

def callback(async_result: AsyncResult[UpdateStaminaByUserIdResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_stamina_by_user_id_async(
    UpdateStaminaByUserIdRequest()\
    callback
)
import io.gs2.stamina.request.UpdateStaminaByUserIdRequest
import io.gs2.stamina.result.UpdateStaminaByUserIdResult

result = client.updateStaminaByUserId(
    UpdateStaminaByUserIdRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

ユーザIDを指定してスタミナを作成・更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
userId string false ユーザーID
value integer true 最終更新時におけるスタミナ値
maxValue integer true スタミナの最大値
recoverIntervalMinutes integer false スタミナの回復間隔(分)
recoverValue integer false スタミナの回復量
パラメータ データ型 説明
item Stamina スタミナ

updateStaminaModelMaster

同期処理

from gs2_stamina_client.request import UpdateStaminaModelMasterRequest
from gs2_stamina_client.result import UpdateStaminaModelMasterResult

result = client.update_stamina_model_master(
    UpdateStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001')\
        .with_description('description1')\
        .with_metadata('STAMINA_MODEL_MASTER_0001')\
        .with_recover_interval_minutes(20)\
        .with_recover_value(2)\
        .with_initial_capacity(60)\
        .with_is_overflow(True)\
        .with_max_capacity(999)\
        .with_max_stamina_table_id(max_stamina_table2['maxStaminaTableId'])\
        .with_recover_interval_table_id(recover_interval_table2['recoverIntervalTableId'])\
        .with_recover_value_table_id(recover_value_table2['recoverValueTableId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.stamina.request.UpdateStaminaModelMasterRequest
import io.gs2.stamina.result.UpdateStaminaModelMasterResult

result = client.updateStaminaModelMaster(
    UpdateStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001")
        .withDescription("description1")
        .withMetadata("STAMINA_MODEL_MASTER_0001")
        .withRecoverIntervalMinutes(20)
        .withRecoverValue(2)
        .withInitialCapacity(60)
        .withIsOverflow(true)
        .withMaxCapacity(999)
        .withMaxStaminaTableId(max_stamina_table2.get'MaxStaminaTableId())
        .withRecoverIntervalTableId(recover_interval_table2.get'RecoverIntervalTableId())
        .withRecoverValueTableId(recover_value_table2.get'RecoverValueTableId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_stamina_client.request import UpdateStaminaModelMasterRequest
from gs2_stamina_client.result import UpdateStaminaModelMasterResult

def callback(async_result: AsyncResult[UpdateStaminaModelMasterResult]):
    if async_result.error:
        #  エラー発生時には async_result.error に例外が格納
        raise async_result.error
    # async_result.result が成功結果格納

result = client.update_stamina_model_master_async(
    UpdateStaminaModelMasterRequest()\
        .with_namespace_name('namespace-0001')\
        .with_stamina_name('stamina-0001')\
        .with_description('description1')\
        .with_metadata('STAMINA_MODEL_MASTER_0001')\
        .with_recover_interval_minutes(20)\
        .with_recover_value(2)\
        .with_initial_capacity(60)\
        .with_is_overflow(True)\
        .with_max_capacity(999)\
        .with_max_stamina_table_id(max_stamina_table2['maxStaminaTableId'])\
        .with_recover_interval_table_id(recover_interval_table2['recoverIntervalTableId'])\
        .with_recover_value_table_id(recover_value_table2['recoverValueTableId']),
    callback
)
import io.gs2.stamina.request.UpdateStaminaModelMasterRequest
import io.gs2.stamina.result.UpdateStaminaModelMasterResult

result = client.updateStaminaModelMaster(
    UpdateStaminaModelMasterRequest()
        .withNamespaceName("namespace-0001")
        .withStaminaName("stamina-0001")
        .withDescription("description1")
        .withMetadata("STAMINA_MODEL_MASTER_0001")
        .withRecoverIntervalMinutes(20)
        .withRecoverValue(2)
        .withInitialCapacity(60)
        .withIsOverflow(true)
        .withMaxCapacity(999)
        .withMaxStaminaTableId(max_stamina_table2.get'MaxStaminaTableId())
        .withRecoverIntervalTableId(recover_interval_table2.get'RecoverIntervalTableId())
        .withRecoverValueTableId(recover_value_table2.get'RecoverValueTableId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

GS2-Deploy から利用できません

スタミナモデルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
staminaName string true スタミナの種類名
description string false スタミナモデルマスターの説明
metadata string false スタミナの種類のメタデータ
recoverIntervalMinutes integer true スタミナを回復する速度(分)
recoverValue integer true 時間経過後に回復する量
initialCapacity integer true スタミナの最大値の初期値
isOverflow boolean true 最大値を超えて回復するか
maxCapacity integer true 溢れた状況での最大値
maxStaminaTableId string false GS2-Experience のランクによって最大スタミナ値を決定する
recoverIntervalTableId string false GS2-Experience のランクによってスタミナの回復間隔を決定する
recoverValueTableId string false GS2-Experience のランクによってスタミナの回復量を決定する
パラメータ データ型 説明
item StaminaModelMaster 更新したスタミナモデルマスター

GS2-Script トリガーイベント

OverflowTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
stamina_model = args['staminaModel']  -- type: StaminaModel
stamina = args['stamina']  -- type: Stamina
overflow_value = args['overflowValue']  -- type: long

result = {
}

スタミナがオーバーフロー最大値を超えた時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
staminaModel StaminaModel スタミナモデル
stamina Stamina スタミナ
overflowValue long None
パラメータ データ型 説明

マスターデータフォーマット

CurrentStaminaMaster

{
  "version": "2019-02-14"
  "staminaModels": [
    {
      "name": "[string] スタミナの種類名",
      "metadata": "[string] スタミナの種類のメタデータ",
      "recoverIntervalMinutes": "[integer] スタミナを回復する速度(分)",
      "recoverValue": "[integer] 時間経過後に回復する量",
      "initialCapacity": "[integer] スタミナの最大値の初期値",
      "isOverflow": "[boolean] 最大値を超えて回復するか",
      "maxCapacity": "[integer] 溢れた状況での最大値",
      "maxStaminaTable": [
        {
          "name": "[string] 最大スタミナ値テーブル名",
          "metadata": "[string] 最大スタミナ値テーブルのメタデータ",
          "experienceModelId": "[string] 経験値の種類マスター のGRN",
          "values": 
          ["[integer] スタミナの最大値"
          ]
        },
      ],
      "recoverIntervalTable": [
        {
          "name": "[string] スタミナ回復間隔テーブル名",
          "metadata": "[string] スタミナ回復間隔テーブルのメタデータ",
          "experienceModelId": "[string] 経験値の種類マスター のGRN",
          "values": 
          ["[integer] スタミナ回復間隔"
          ]
        },
      ],
      "recoverValueTable": [
        {
          "name": "[string] スタミナ回復量テーブル名",
          "metadata": "[string] スタミナ回復量テーブルのメタデータ",
          "experienceModelId": "[string] 経験値の種類マスター のGRN",
          "values": 
          ["[integer] スタミナ回復量"
          ]
        }
      ]
    }
  ]
}

現在有効なスタミナマスター

エクスポートしたマスターデータを、現在有効なスタミナマスターとしてインポートして使用します。

GS2-Stamina の制限・制約

利用いただくにあたって注意いただく制限・制約はありません