NAV Navbar
Python Java GS2-Formation
 

GS2-Experience

キャラクターやスキルのレベル、親愛度など、経験値を積み重ねてランクアップしていく仕組みの実現に使用します。 ランクキャップ機能も有しており、キャラクターやスキルなど個別の要素ごとに上限管理を行うことができます。

GS2-Experience のデータ構造は以下です。

モデル

Namespace

ネームスペース

ネームスペースには経験値モデル(デフォルトのランクキャップ・ランク最大値・適用するランクアップテーブルなどの情報)を最大100種類指定できます。 100種類超える見込みがある場合はネームスペースを経験値のカテゴリごとに分割することを事前に検討してください。

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

パラメータ データ型 必須 説明
namespaceId string true ネームスペース
ownerId string true オーナーID
name string true ネームスペース名
description string false ネームスペースの説明
experienceCapScriptId string false ランクキャップ取得時 に実行されるスクリプト のGRN
changeExperienceScript ScriptSetting false 経験値変化したときに実行するスクリプト
changeRankScript ScriptSetting false ランク変化したときに実行するスクリプト
changeRankCapScript ScriptSetting false ランクキャップ変化したときに実行するスクリプト
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

ExperienceModelMaster

経験値の種類マスター

ランクキャップの初期値・最大値や、ランクアップのしきい値が異なる要素ごとに種類を定義します。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
experienceModelId string true 経験値の種類マスター
name string true 経験値の種類名
description string false 経験値の種類マスターの説明
metadata string false 経験値の種類のメタデータ
defaultExperience long true 経験値の初期値
defaultRankCap long true ランクキャップの初期値
maxRankCap long true ランクキャップの最大値
rankThresholdId string true ランク計算に用いる
createdAt long true 作成日時
updatedAt long true 最終更新日時

ExperienceModel

経験値・ランクアップ閾値モデル

ランクキャップの初期値・最大値や、ランクアップのしきい値が異なる要素ごとに種類を定義します。

パラメータ データ型 必須 説明
experienceModelId string true 経験値の種類マスター
name string true 経験値の種類名
metadata string false 経験値の種類のメタデータ
defaultExperience long true 経験値の初期値
defaultRankCap long true ランクキャップの初期値
maxRankCap long true ランクキャップの最大値
rankThreshold Threshold false ランクアップ閾値

ThresholdMaster

ランクアップ閾値マスター

ランクアップに必要な経験値テーブルを定義 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
thresholdId string true ランクアップ閾値マスター
name string true ランクアップ閾値名
description string false ランクアップ閾値マスターの説明
metadata string false ランクアップ閾値のメタデータ
values list[long] true ランクアップ経験値閾値リスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

Threshold

ランクアップ閾値

ランクアップに必要な経験値テーブルを定義

パラメータ データ型 必須 説明
thresholdId string false しきい値ID
metadata string false ランクアップ閾値のメタデータ
values list[long] true ランクアップ経験値閾値リスト

CurrentExperienceMaster

現在有効な経験値設定

エクスポートしたマスターデータを、現在有効な経験値設定としてインポートして使用します。

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

User

ユーザ

パラメータ データ型 必須 説明
userId string true ユーザーID

Status

ステータス

獲得経験値・現在のランク・ランクキャップ情報を格納します。

パラメータ データ型 必須 説明
statusId string true ステータス
experienceName string true 経験値の種類の名前
userId string false ユーザーID
propertyId string true プロパティID
experienceValue long true 累計獲得経験値
rankValue long true 現在のランク
rankCapValue long true 現在のランクキャップ
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 タグ名

ScriptSetting

スクリプト設定

パラメータ データ型 必須 説明
triggerScriptId string false 実行前に使用する GS2-Script のスクリプト のGRN
doneTriggerScriptId string false 完了時に使用する GS2-Script のスクリプト のGRN
doneTriggerQueueNamespaceId string false 完了時に使用する GS2-JobQueue のネームスペース のGRN

LogSetting

ロギング通知設定

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

初期化処理

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

import gs2_core_client.model.*
import gs2_experience_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_experience_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 = Gs2ExperienceRestClient(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.experience.rest.Gs2ExperienceRestClient

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

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

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

import gs2_core_client.model.*
import gs2_experience_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 = Gs2ExperienceWebSocketClient(session)
import io.gs2.core.model.Region
import io.gs2.core.model.BasicGs2Credential
import io.gs2.core.webSocket.Gs2WebSocketSession
import io.gs2.experience.webSocket.Gs2ExperienceWebSocketClient

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

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

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

import gs2_core_client.model.*
import gs2_experience_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 = Gs2ExperienceWebSocketClient(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.experience.webSocket.Gs2ExperienceWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

addExperienceByStampSheet

同期処理

from gs2_experience_client.request import AddExperienceByStampSheetRequest
from gs2_experience_client.result import AddExperienceByStampSheetResult

result = client.add_experience_by_stamp_sheet(
    AddExperienceByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.AddExperienceByStampSheetRequest
import io.gs2.experience.result.AddExperienceByStampSheetResult

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

非同期処理

from gs2_experience_client.request import AddExperienceByStampSheetRequest
from gs2_experience_client.result import AddExperienceByStampSheetResult

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

result = client.add_experience_by_stamp_sheet_async(
    AddExperienceByStampSheetRequest()\
    callback
)
import io.gs2.experience.request.AddExperienceByStampSheetRequest
import io.gs2.experience.result.AddExperienceByStampSheetResult

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

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

経験値を加算

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

addExperienceByUserId

同期処理

from gs2_experience_client.request import AddExperienceByUserIdRequest
from gs2_experience_client.result import AddExperienceByUserIdResult

result = client.add_experience_by_user_id(
    AddExperienceByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.AddExperienceByUserIdRequest
import io.gs2.experience.result.AddExperienceByUserIdResult

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

非同期処理

from gs2_experience_client.request import AddExperienceByUserIdRequest
from gs2_experience_client.result import AddExperienceByUserIdResult

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

result = client.add_experience_by_user_id_async(
    AddExperienceByUserIdRequest()\
    callback
)
import io.gs2.experience.request.AddExperienceByUserIdRequest
import io.gs2.experience.result.AddExperienceByUserIdResult

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

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

経験値を加算

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
experienceValue long true 加算する経験値量
パラメータ データ型 説明
item Status 加算後のステータス

addRankCapByStampSheet

同期処理

from gs2_experience_client.request import AddRankCapByStampSheetRequest
from gs2_experience_client.result import AddRankCapByStampSheetResult

result = client.add_rank_cap_by_stamp_sheet(
    AddRankCapByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.AddRankCapByStampSheetRequest
import io.gs2.experience.result.AddRankCapByStampSheetResult

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

非同期処理

from gs2_experience_client.request import AddRankCapByStampSheetRequest
from gs2_experience_client.result import AddRankCapByStampSheetResult

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

result = client.add_rank_cap_by_stamp_sheet_async(
    AddRankCapByStampSheetRequest()\
    callback
)
import io.gs2.experience.request.AddRankCapByStampSheetRequest
import io.gs2.experience.result.AddRankCapByStampSheetResult

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

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

ランクキャップを加算

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

addRankCapByUserId

同期処理

from gs2_experience_client.request import AddRankCapByUserIdRequest
from gs2_experience_client.result import AddRankCapByUserIdResult

result = client.add_rank_cap_by_user_id(
    AddRankCapByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.AddRankCapByUserIdRequest
import io.gs2.experience.result.AddRankCapByUserIdResult

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

非同期処理

from gs2_experience_client.request import AddRankCapByUserIdRequest
from gs2_experience_client.result import AddRankCapByUserIdResult

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

result = client.add_rank_cap_by_user_id_async(
    AddRankCapByUserIdRequest()\
    callback
)
import io.gs2.experience.request.AddRankCapByUserIdRequest
import io.gs2.experience.result.AddRankCapByUserIdResult

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

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

ランクキャップを加算

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
rankCapValue long true 加算するランクキャップ量
パラメータ データ型 説明
item Status 加算後のステータス

createExperienceModelMaster

同期処理

from gs2_experience_client.request import CreateExperienceModelMasterRequest
from gs2_experience_client.result import CreateExperienceModelMasterResult

result = client.create_experience_model_master(
    CreateExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_name('experience-model-0001')\
        .with_default_rank_cap(50)\
        .with_max_rank_cap(50)\
        .with_rank_threshold_id(threshold1['thresholdId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.CreateExperienceModelMasterRequest
import io.gs2.experience.result.CreateExperienceModelMasterResult

result = client.createExperienceModelMaster(
    CreateExperienceModelMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withName("experience-model-0001")
        .withDefaultRankCap(50l)
        .withMaxRankCap(50l)
        .withRankThresholdId(threshold1.get'ThresholdId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import CreateExperienceModelMasterRequest
from gs2_experience_client.result import CreateExperienceModelMasterResult

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

result = client.create_experience_model_master_async(
    CreateExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_name('experience-model-0001')\
        .with_default_rank_cap(50)\
        .with_max_rank_cap(50)\
        .with_rank_threshold_id(threshold1['thresholdId']),
    callback
)
import io.gs2.experience.request.CreateExperienceModelMasterRequest
import io.gs2.experience.result.CreateExperienceModelMasterResult

result = client.createExperienceModelMaster(
    CreateExperienceModelMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withName("experience-model-0001")
        .withDefaultRankCap(50l)
        .withMaxRankCap(50l)
        .withRankThresholdId(threshold1.get'ThresholdId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Experience::ExperienceModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  DefaultExperience: Long
  DefaultRankCap: Long
  MaxRankCap: Long
  RankThresholdId: String

経験値の種類マスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true 経験値の種類名
description string false 経験値の種類マスターの説明
metadata string false 経験値の種類のメタデータ
defaultExperience long true 経験値の初期値
defaultRankCap long true ランクキャップの初期値
maxRankCap long true ランクキャップの最大値
rankThresholdId string true ランク計算に用いる
パラメータ データ型 説明
item ExperienceModelMaster 作成した経験値の種類マスター

createNamespace

同期処理

from gs2_experience_client.request import CreateNamespaceRequest
from gs2_experience_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_experience_client.request import CreateNamespaceRequest
from gs2_experience_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('namespaceId-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.experience.request.CreateNamespaceRequest
import io.gs2.experience.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("namespaceId-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::Experience::Namespace
Properties:
  Name: String
  Description: Optional[String]
  ExperienceCapScriptId: Optional[String]
  ChangeExperienceScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  ChangeRankScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  ChangeRankCapScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  LogSetting:
    LoggingNamespaceId: Optional[String]

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

パラメータ データ型 必須 説明
name string true ネームスペース名
description string false ネームスペースの説明
experienceCapScriptId string false ランクキャップ取得時 に実行されるスクリプト のGRN
changeExperienceScript ScriptSetting false 経験値変化したときに実行するスクリプト
changeRankScript ScriptSetting false ランク変化したときに実行するスクリプト
changeRankCapScript ScriptSetting false ランクキャップ変化したときに実行するスクリプト
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したネームスペース

createThresholdMaster

同期処理

from gs2_experience_client.request import CreateThresholdMasterRequest
from gs2_experience_client.result import CreateThresholdMasterResult

result = client.create_threshold_master(
    CreateThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_name('threshold-0001')\
        .with_values([
100,    
200,    
300
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.CreateThresholdMasterRequest
import io.gs2.experience.result.CreateThresholdMasterResult

result = client.createThresholdMaster(
    CreateThresholdMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withName("threshold-0001")
        .withValues(new [] {
100l,   
200l,   
300l
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import CreateThresholdMasterRequest
from gs2_experience_client.result import CreateThresholdMasterResult

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

result = client.create_threshold_master_async(
    CreateThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_name('threshold-0001')\
        .with_values([
100,    
200,    
300
]),
    callback
)
import io.gs2.experience.request.CreateThresholdMasterRequest
import io.gs2.experience.result.CreateThresholdMasterResult

result = client.createThresholdMaster(
    CreateThresholdMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withName("threshold-0001")
        .withValues(new [] {
100l,   
200l,   
300l
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Experience::ThresholdMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  Values:
    - Long
    - Long

ランクアップ閾値マスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
name string true ランクアップ閾値名
description string false ランクアップ閾値マスターの説明
metadata string false ランクアップ閾値のメタデータ
values list[long] true ランクアップ経験値閾値リスト
パラメータ データ型 説明
item ThresholdMaster 作成したランクアップ閾値マスター

deleteExperienceModelMaster

同期処理

from gs2_experience_client.request import DeleteExperienceModelMasterRequest
from gs2_experience_client.result import DeleteExperienceModelMasterResult

result = client.delete_experience_model_master(
    DeleteExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_experience_name('experience-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DeleteExperienceModelMasterRequest
import io.gs2.experience.result.DeleteExperienceModelMasterResult

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

非同期処理

from gs2_experience_client.request import DeleteExperienceModelMasterRequest
from gs2_experience_client.result import DeleteExperienceModelMasterResult

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

result = client.delete_experience_model_master_async(
    DeleteExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_experience_name('experience-model-0001'),
    callback
)
import io.gs2.experience.request.DeleteExperienceModelMasterRequest
import io.gs2.experience.result.DeleteExperienceModelMasterResult

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

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

経験値の種類マスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
experienceName string true 経験値の種類名
パラメータ データ型 説明
item ExperienceModelMaster 削除した経験値の種類マスター

deleteNamespace

同期処理

from gs2_experience_client.request import DeleteNamespaceRequest
from gs2_experience_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_experience_client.request import DeleteNamespaceRequest
from gs2_experience_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('namespaceId-0001'),
    callback
)
import io.gs2.experience.request.DeleteNamespaceRequest
import io.gs2.experience.result.DeleteNamespaceResult

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

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

ネームスペースを削除

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

deleteStatusByUserId

同期処理

from gs2_experience_client.request import DeleteStatusByUserIdRequest
from gs2_experience_client.result import DeleteStatusByUserIdResult

result = client.delete_status_by_user_id(
    DeleteStatusByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DeleteStatusByUserIdRequest
import io.gs2.experience.result.DeleteStatusByUserIdResult

result = client.deleteStatusByUserId(
    DeleteStatusByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import DeleteStatusByUserIdRequest
from gs2_experience_client.result import DeleteStatusByUserIdResult

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

result = client.delete_status_by_user_id_async(
    DeleteStatusByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0001'),
    callback
)
import io.gs2.experience.request.DeleteStatusByUserIdRequest
import io.gs2.experience.result.DeleteStatusByUserIdResult

result = client.deleteStatusByUserId(
    DeleteStatusByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ステータスを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
パラメータ データ型 説明
item Status ステータス

deleteThresholdMaster

同期処理

from gs2_experience_client.request import DeleteThresholdMasterRequest
from gs2_experience_client.result import DeleteThresholdMasterResult

result = client.delete_threshold_master(
    DeleteThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_threshold_name('threshold-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DeleteThresholdMasterRequest
import io.gs2.experience.result.DeleteThresholdMasterResult

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

非同期処理

from gs2_experience_client.request import DeleteThresholdMasterRequest
from gs2_experience_client.result import DeleteThresholdMasterResult

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

result = client.delete_threshold_master_async(
    DeleteThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_threshold_name('threshold-0001'),
    callback
)
import io.gs2.experience.request.DeleteThresholdMasterRequest
import io.gs2.experience.result.DeleteThresholdMasterResult

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

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

ランクアップ閾値マスターを削除

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
thresholdName string true ランクアップ閾値名
パラメータ データ型 説明
item ThresholdMaster 削除したランクアップ閾値マスター

describeExperienceModelMasters

同期処理

from gs2_experience_client.request import DescribeExperienceModelMastersRequest
from gs2_experience_client.result import DescribeExperienceModelMastersResult

result = client.describe_experience_model_masters(
    DescribeExperienceModelMastersRequest()\
        .with_namespace_name('namespaceId-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DescribeExperienceModelMastersRequest
import io.gs2.experience.result.DescribeExperienceModelMastersResult

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

非同期処理

from gs2_experience_client.request import DescribeExperienceModelMastersRequest
from gs2_experience_client.result import DescribeExperienceModelMastersResult

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

result = client.describe_experience_model_masters_async(
    DescribeExperienceModelMastersRequest()\
        .with_namespace_name('namespaceId-0001'),
    callback
)
import io.gs2.experience.request.DescribeExperienceModelMastersRequest
import io.gs2.experience.result.DescribeExperienceModelMastersResult

result = client.describeExperienceModelMasters(
    DescribeExperienceModelMastersRequest()
        .withNamespaceName("namespaceId-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[ExperienceModelMaster] 経験値の種類マスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeExperienceModels

同期処理

from gs2_experience_client.request import DescribeExperienceModelsRequest
from gs2_experience_client.result import DescribeExperienceModelsResult

result = client.describe_experience_models(
    DescribeExperienceModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DescribeExperienceModelsRequest
import io.gs2.experience.result.DescribeExperienceModelsResult

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

非同期処理

from gs2_experience_client.request import DescribeExperienceModelsRequest
from gs2_experience_client.result import DescribeExperienceModelsResult

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

result = client.describe_experience_models_async(
    DescribeExperienceModelsRequest()\
    callback
)
import io.gs2.experience.request.DescribeExperienceModelsRequest
import io.gs2.experience.result.DescribeExperienceModelsResult

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

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

経験値・ランクアップ閾値モデルの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
items list[ExperienceModel] 経験値・ランクアップ閾値モデルのリスト

describeNamespaces

同期処理

from gs2_experience_client.request import DescribeNamespacesRequest
from gs2_experience_client.result import DescribeNamespacesResult

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

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

非同期処理

from gs2_experience_client.request import DescribeNamespacesRequest
from gs2_experience_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.experience.request.DescribeNamespacesRequest
import io.gs2.experience.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 リストの続きを取得するためのページトークン

describeStatuses

同期処理

from gs2_experience_client.request import DescribeStatusesRequest
from gs2_experience_client.result import DescribeStatusesResult

result = client.describe_statuses(
    DescribeStatusesRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_experience_name('experience-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DescribeStatusesRequest
import io.gs2.experience.result.DescribeStatusesResult

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

非同期処理

from gs2_experience_client.request import DescribeStatusesRequest
from gs2_experience_client.result import DescribeStatusesResult

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

result = client.describe_statuses_async(
    DescribeStatusesRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_experience_name('experience-model-0001'),
    callback
)
import io.gs2.experience.request.DescribeStatusesRequest
import io.gs2.experience.result.DescribeStatusesResult

result = client.describeStatuses(
    DescribeStatusesRequest()
        .withNamespaceName("namespaceId-0002")
        .withExperienceName("experience-model-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ステータスの一覧を取得

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

describeStatusesByUserId

同期処理

from gs2_experience_client.request import DescribeStatusesByUserIdRequest
from gs2_experience_client.result import DescribeStatusesByUserIdResult

result = client.describe_statuses_by_user_id(
    DescribeStatusesByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_experience_name('experience-model-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DescribeStatusesByUserIdRequest
import io.gs2.experience.result.DescribeStatusesByUserIdResult

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

非同期処理

from gs2_experience_client.request import DescribeStatusesByUserIdRequest
from gs2_experience_client.result import DescribeStatusesByUserIdResult

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

result = client.describe_statuses_by_user_id_async(
    DescribeStatusesByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_experience_name('experience-model-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.experience.request.DescribeStatusesByUserIdRequest
import io.gs2.experience.result.DescribeStatusesByUserIdResult

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

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

ステータスの一覧を取得

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

describeThresholdMasters

同期処理

from gs2_experience_client.request import DescribeThresholdMastersRequest
from gs2_experience_client.result import DescribeThresholdMastersResult

result = client.describe_threshold_masters(
    DescribeThresholdMastersRequest()\
        .with_namespace_name('namespaceId-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.DescribeThresholdMastersRequest
import io.gs2.experience.result.DescribeThresholdMastersResult

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

非同期処理

from gs2_experience_client.request import DescribeThresholdMastersRequest
from gs2_experience_client.result import DescribeThresholdMastersResult

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

result = client.describe_threshold_masters_async(
    DescribeThresholdMastersRequest()\
        .with_namespace_name('namespaceId-0001'),
    callback
)
import io.gs2.experience.request.DescribeThresholdMastersRequest
import io.gs2.experience.result.DescribeThresholdMastersResult

result = client.describeThresholdMasters(
    DescribeThresholdMastersRequest()
        .withNamespaceName("namespaceId-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[ThresholdMaster] ランクアップ閾値マスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

exportMaster

同期処理

from gs2_experience_client.request import ExportMasterRequest
from gs2_experience_client.result import ExportMasterResult

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

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

非同期処理

from gs2_experience_client.request import ExportMasterRequest
from gs2_experience_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.experience.request.ExportMasterRequest
import io.gs2.experience.result.ExportMasterResult

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

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

現在有効な経験値設定のマスターデータをエクスポートします

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentExperienceMaster 現在有効な経験値設定

getCurrentExperienceMaster

同期処理

from gs2_experience_client.request import GetCurrentExperienceMasterRequest
from gs2_experience_client.result import GetCurrentExperienceMasterResult

result = client.get_current_experience_master(
    GetCurrentExperienceMasterRequest()\
        .with_namespace_name('namespaceId-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetCurrentExperienceMasterRequest
import io.gs2.experience.result.GetCurrentExperienceMasterResult

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

非同期処理

from gs2_experience_client.request import GetCurrentExperienceMasterRequest
from gs2_experience_client.result import GetCurrentExperienceMasterResult

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

result = client.get_current_experience_master_async(
    GetCurrentExperienceMasterRequest()\
        .with_namespace_name('namespaceId-0001'),
    callback
)
import io.gs2.experience.request.GetCurrentExperienceMasterRequest
import io.gs2.experience.result.GetCurrentExperienceMasterResult

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

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

現在有効な経験値設定を取得します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
パラメータ データ型 説明
item CurrentExperienceMaster 現在有効な経験値設定

getExperienceModel

同期処理

from gs2_experience_client.request import GetExperienceModelRequest
from gs2_experience_client.result import GetExperienceModelResult

result = client.get_experience_model(
    GetExperienceModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetExperienceModelRequest
import io.gs2.experience.result.GetExperienceModelResult

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

非同期処理

from gs2_experience_client.request import GetExperienceModelRequest
from gs2_experience_client.result import GetExperienceModelResult

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

result = client.get_experience_model_async(
    GetExperienceModelRequest()\
    callback
)
import io.gs2.experience.request.GetExperienceModelRequest
import io.gs2.experience.result.GetExperienceModelResult

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

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

経験値・ランクアップ閾値モデルを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
experienceName string true 経験値の種類名
パラメータ データ型 説明
item ExperienceModel 経験値・ランクアップ閾値モデル

getExperienceModelMaster

同期処理

from gs2_experience_client.request import GetExperienceModelMasterRequest
from gs2_experience_client.result import GetExperienceModelMasterResult

result = client.get_experience_model_master(
    GetExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_experience_name('experience-model-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetExperienceModelMasterRequest
import io.gs2.experience.result.GetExperienceModelMasterResult

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

非同期処理

from gs2_experience_client.request import GetExperienceModelMasterRequest
from gs2_experience_client.result import GetExperienceModelMasterResult

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

result = client.get_experience_model_master_async(
    GetExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_experience_name('experience-model-0001'),
    callback
)
import io.gs2.experience.request.GetExperienceModelMasterRequest
import io.gs2.experience.result.GetExperienceModelMasterResult

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

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

経験値の種類マスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
experienceName string true 経験値の種類名
パラメータ データ型 説明
item ExperienceModelMaster 経験値の種類マスター

getNamespace

同期処理

from gs2_experience_client.request import GetNamespaceRequest
from gs2_experience_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_experience_client.request import GetNamespaceRequest
from gs2_experience_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('namespaceId-0001'),
    callback
)
import io.gs2.experience.request.GetNamespaceRequest
import io.gs2.experience.result.GetNamespaceResult

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

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

ネームスペースを取得

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

getNamespaceStatus

同期処理

from gs2_experience_client.request import GetNamespaceStatusRequest
from gs2_experience_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_experience_client.request import GetNamespaceStatusRequest
from gs2_experience_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()\
        .with_namespace_name('namespaceId-0001'),
    callback
)
import io.gs2.experience.request.GetNamespaceStatusRequest
import io.gs2.experience.result.GetNamespaceStatusResult

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

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

ネームスペースを取得

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

getStatus

同期処理

from gs2_experience_client.request import GetStatusRequest
from gs2_experience_client.result import GetStatusResult

result = client.get_status(
    GetStatusRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetStatusRequest
import io.gs2.experience.result.GetStatusResult

result = client.getStatus(
    GetStatusRequest()
        .withNamespaceName("namespaceId-0002")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import GetStatusRequest
from gs2_experience_client.result import GetStatusResult

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

result = client.get_status_async(
    GetStatusRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0001'),
    callback
)
import io.gs2.experience.request.GetStatusRequest
import io.gs2.experience.result.GetStatusResult

result = client.getStatus(
    GetStatusRequest()
        .withNamespaceName("namespaceId-0002")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ステータスを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
パラメータ データ型 説明
item Status ステータス

getStatusByUserId

同期処理

from gs2_experience_client.request import GetStatusByUserIdRequest
from gs2_experience_client.result import GetStatusByUserIdResult

result = client.get_status_by_user_id(
    GetStatusByUserIdRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetStatusByUserIdRequest
import io.gs2.experience.result.GetStatusByUserIdResult

result = client.getStatusByUserId(
    GetStatusByUserIdRequest()
        .withNamespaceName("namespaceId-0001")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import GetStatusByUserIdRequest
from gs2_experience_client.result import GetStatusByUserIdResult

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

result = client.get_status_by_user_id_async(
    GetStatusByUserIdRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0002'),
    callback
)
import io.gs2.experience.request.GetStatusByUserIdRequest
import io.gs2.experience.result.GetStatusByUserIdResult

result = client.getStatusByUserId(
    GetStatusByUserIdRequest()
        .withNamespaceName("namespaceId-0001")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ステータスを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
パラメータ データ型 説明
item Status ステータス

getStatusWithSignature

同期処理

from gs2_experience_client.request import GetStatusWithSignatureRequest
from gs2_experience_client.result import GetStatusWithSignatureResult

result = client.get_status_with_signature(
    GetStatusWithSignatureRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetStatusWithSignatureRequest
import io.gs2.experience.result.GetStatusWithSignatureResult

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

非同期処理

from gs2_experience_client.request import GetStatusWithSignatureRequest
from gs2_experience_client.result import GetStatusWithSignatureResult

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

result = client.get_status_with_signature_async(
    GetStatusWithSignatureRequest()\
    callback
)
import io.gs2.experience.request.GetStatusWithSignatureRequest
import io.gs2.experience.result.GetStatusWithSignatureResult

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

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

ステータスを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
keyId string true 署名の作成に使用する 暗号鍵 のGRN
パラメータ データ型 説明
item Status ステータス
body string 検証対象のオブジェクト
signature string 署名

getThresholdMaster

同期処理

from gs2_experience_client.request import GetThresholdMasterRequest
from gs2_experience_client.result import GetThresholdMasterResult

result = client.get_threshold_master(
    GetThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_threshold_name('threshold-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.GetThresholdMasterRequest
import io.gs2.experience.result.GetThresholdMasterResult

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

非同期処理

from gs2_experience_client.request import GetThresholdMasterRequest
from gs2_experience_client.result import GetThresholdMasterResult

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

result = client.get_threshold_master_async(
    GetThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_threshold_name('threshold-0001'),
    callback
)
import io.gs2.experience.request.GetThresholdMasterRequest
import io.gs2.experience.result.GetThresholdMasterResult

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

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

ランクアップ閾値マスターを取得

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
thresholdName string true ランクアップ閾値名
パラメータ データ型 説明
item ThresholdMaster ランクアップ閾値マスター

setExperienceByUserId

同期処理

from gs2_experience_client.request import SetExperienceByUserIdRequest
from gs2_experience_client.result import SetExperienceByUserIdResult

result = client.set_experience_by_user_id(
    SetExperienceByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0001')\
        .with_experience_value(100)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.SetExperienceByUserIdRequest
import io.gs2.experience.result.SetExperienceByUserIdResult

result = client.setExperienceByUserId(
    SetExperienceByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0001")
        .withExperienceValue(100l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import SetExperienceByUserIdRequest
from gs2_experience_client.result import SetExperienceByUserIdResult

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

result = client.set_experience_by_user_id_async(
    SetExperienceByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0001')\
        .with_property_id('property-0001')\
        .with_experience_value(100),
    callback
)
import io.gs2.experience.request.SetExperienceByUserIdRequest
import io.gs2.experience.result.SetExperienceByUserIdResult

result = client.setExperienceByUserId(
    SetExperienceByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0001")
        .withPropertyId("property-0001")
        .withExperienceValue(100l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

累計獲得経験値を設定

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
experienceValue long true 累計獲得経験値
パラメータ データ型 説明
item Status 更新後のステータス

setRankCapByStampSheet

同期処理

from gs2_experience_client.request import SetRankCapByStampSheetRequest
from gs2_experience_client.result import SetRankCapByStampSheetResult

result = client.set_rank_cap_by_stamp_sheet(
    SetRankCapByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.SetRankCapByStampSheetRequest
import io.gs2.experience.result.SetRankCapByStampSheetResult

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

非同期処理

from gs2_experience_client.request import SetRankCapByStampSheetRequest
from gs2_experience_client.result import SetRankCapByStampSheetResult

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

result = client.set_rank_cap_by_stamp_sheet_async(
    SetRankCapByStampSheetRequest()\
    callback
)
import io.gs2.experience.request.SetRankCapByStampSheetRequest
import io.gs2.experience.result.SetRankCapByStampSheetResult

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

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

ランクキャップを更新

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

setRankCapByUserId

同期処理

from gs2_experience_client.request import SetRankCapByUserIdRequest
from gs2_experience_client.result import SetRankCapByUserIdResult

result = client.set_rank_cap_by_user_id(
    SetRankCapByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0002')\
        .with_property_id('property-0001')\
        .with_rank_cap_value(5)
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.SetRankCapByUserIdRequest
import io.gs2.experience.result.SetRankCapByUserIdResult

result = client.setRankCapByUserId(
    SetRankCapByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0002")
        .withPropertyId("property-0001")
        .withRankCapValue(5l)
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import SetRankCapByUserIdRequest
from gs2_experience_client.result import SetRankCapByUserIdResult

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

result = client.set_rank_cap_by_user_id_async(
    SetRankCapByUserIdRequest()\
        .with_namespace_name('namespaceId-0002')\
        .with_user_id('user-0001')\
        .with_experience_name('experience-model-0002')\
        .with_property_id('property-0001')\
        .with_rank_cap_value(5),
    callback
)
import io.gs2.experience.request.SetRankCapByUserIdRequest
import io.gs2.experience.result.SetRankCapByUserIdResult

result = client.setRankCapByUserId(
    SetRankCapByUserIdRequest()
        .withNamespaceName("namespaceId-0002")
        .withUserId("user-0001")
        .withExperienceName("experience-model-0002")
        .withPropertyId("property-0001")
        .withRankCapValue(5l),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ランクキャップを設定

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
userId string false ユーザーID
experienceName string true 経験値の種類の名前
propertyId string true プロパティID
rankCapValue long true ランクキャップ
パラメータ データ型 説明
item Status 更新後のステータス

updateCurrentExperienceMaster

同期処理

from gs2_experience_client.request import UpdateCurrentExperienceMasterRequest
from gs2_experience_client.result import UpdateCurrentExperienceMasterResult

result = client.update_current_experience_master(
    UpdateCurrentExperienceMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_settings('{\n  "version": "2019-01-11",\n  "experienceModels": [\n    {\n      "name": "character_ssr",\n      "metadata": "SSR",\n      "defaultExperience": 0,\n      "defaultRankCap": 50,\n      "maxRankCap": 80,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_sr",\n      "metadata": "SR",\n      "defaultExperience": 0,\n      "defaultRankCap": 40,\n      "maxRankCap": 70,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_r",\n      "metadata": "R",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 60,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "equipment",\n      "metadata": "EQUIPMENT",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 50,\n      "rankThreshold": {\n        "metadata": "EQUIPMENT",\n        "values": [\n          200,\n          400,\n          600,\n          800,\n          1000,\n          1200,\n          1400,\n          1600,\n          1800,\n          2000,\n          2200,\n          2400,\n          2600,\n          2800,\n          3000,\n          3200,\n          3400,\n          3600,\n          3800,\n          4000,\n          4200,\n          4400,\n          4600,\n          4800,\n          5000,\n          5200,\n          5400,\n          5600,\n          5800,\n          6000,\n          6200,\n          6400,\n          6600,\n          6800,\n          7000,\n          7200,\n          7400,\n          7600,\n          7800,\n          8000,\n          8200,\n          8400,\n          8600,\n          8800,\n          9000,\n          9200,\n          9400,\n          9600,\n          9800\n        ]\n      }\n    },\n    {\n      "name": "skill",\n      "metadata": "SKILL",\n      "defaultExperience": 0,\n      "defaultRankCap": 10,\n      "maxRankCap": 20,\n      "rankThreshold": {\n        "metadata": "SKILL",\n        "values": [\n          300,\n          600,\n          900,\n          1200,\n          1500,\n          1800,\n          2100,\n          2400,\n          2700,\n          3000,\n          3300,\n          3600,\n          3900,\n          4200,\n          4500,\n          4800,\n          5100,\n          5400,\n          5700\n        ]\n      }\n    }\n  ]\n}')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.UpdateCurrentExperienceMasterRequest
import io.gs2.experience.result.UpdateCurrentExperienceMasterResult

result = client.updateCurrentExperienceMaster(
    UpdateCurrentExperienceMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withSettings("{\n  "version": "2019-01-11",\n  "experienceModels": [\n    {\n      "name": "character_ssr",\n      "metadata": "SSR",\n      "defaultExperience": 0,\n      "defaultRankCap": 50,\n      "maxRankCap": 80,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_sr",\n      "metadata": "SR",\n      "defaultExperience": 0,\n      "defaultRankCap": 40,\n      "maxRankCap": 70,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_r",\n      "metadata": "R",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 60,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "equipment",\n      "metadata": "EQUIPMENT",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 50,\n      "rankThreshold": {\n        "metadata": "EQUIPMENT",\n        "values": [\n          200,\n          400,\n          600,\n          800,\n          1000,\n          1200,\n          1400,\n          1600,\n          1800,\n          2000,\n          2200,\n          2400,\n          2600,\n          2800,\n          3000,\n          3200,\n          3400,\n          3600,\n          3800,\n          4000,\n          4200,\n          4400,\n          4600,\n          4800,\n          5000,\n          5200,\n          5400,\n          5600,\n          5800,\n          6000,\n          6200,\n          6400,\n          6600,\n          6800,\n          7000,\n          7200,\n          7400,\n          7600,\n          7800,\n          8000,\n          8200,\n          8400,\n          8600,\n          8800,\n          9000,\n          9200,\n          9400,\n          9600,\n          9800\n        ]\n      }\n    },\n    {\n      "name": "skill",\n      "metadata": "SKILL",\n      "defaultExperience": 0,\n      "defaultRankCap": 10,\n      "maxRankCap": 20,\n      "rankThreshold": {\n        "metadata": "SKILL",\n        "values": [\n          300,\n          600,\n          900,\n          1200,\n          1500,\n          1800,\n          2100,\n          2400,\n          2700,\n          3000,\n          3300,\n          3600,\n          3900,\n          4200,\n          4500,\n          4800,\n          5100,\n          5400,\n          5700\n        ]\n      }\n    }\n  ]\n}")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import UpdateCurrentExperienceMasterRequest
from gs2_experience_client.result import UpdateCurrentExperienceMasterResult

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

result = client.update_current_experience_master_async(
    UpdateCurrentExperienceMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_settings('{\n  "version": "2019-01-11",\n  "experienceModels": [\n    {\n      "name": "character_ssr",\n      "metadata": "SSR",\n      "defaultExperience": 0,\n      "defaultRankCap": 50,\n      "maxRankCap": 80,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_sr",\n      "metadata": "SR",\n      "defaultExperience": 0,\n      "defaultRankCap": 40,\n      "maxRankCap": 70,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_r",\n      "metadata": "R",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 60,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "equipment",\n      "metadata": "EQUIPMENT",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 50,\n      "rankThreshold": {\n        "metadata": "EQUIPMENT",\n        "values": [\n          200,\n          400,\n          600,\n          800,\n          1000,\n          1200,\n          1400,\n          1600,\n          1800,\n          2000,\n          2200,\n          2400,\n          2600,\n          2800,\n          3000,\n          3200,\n          3400,\n          3600,\n          3800,\n          4000,\n          4200,\n          4400,\n          4600,\n          4800,\n          5000,\n          5200,\n          5400,\n          5600,\n          5800,\n          6000,\n          6200,\n          6400,\n          6600,\n          6800,\n          7000,\n          7200,\n          7400,\n          7600,\n          7800,\n          8000,\n          8200,\n          8400,\n          8600,\n          8800,\n          9000,\n          9200,\n          9400,\n          9600,\n          9800\n        ]\n      }\n    },\n    {\n      "name": "skill",\n      "metadata": "SKILL",\n      "defaultExperience": 0,\n      "defaultRankCap": 10,\n      "maxRankCap": 20,\n      "rankThreshold": {\n        "metadata": "SKILL",\n        "values": [\n          300,\n          600,\n          900,\n          1200,\n          1500,\n          1800,\n          2100,\n          2400,\n          2700,\n          3000,\n          3300,\n          3600,\n          3900,\n          4200,\n          4500,\n          4800,\n          5100,\n          5400,\n          5700\n        ]\n      }\n    }\n  ]\n}'),
    callback
)
import io.gs2.experience.request.UpdateCurrentExperienceMasterRequest
import io.gs2.experience.result.UpdateCurrentExperienceMasterResult

result = client.updateCurrentExperienceMaster(
    UpdateCurrentExperienceMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withSettings("{\n  "version": "2019-01-11",\n  "experienceModels": [\n    {\n      "name": "character_ssr",\n      "metadata": "SSR",\n      "defaultExperience": 0,\n      "defaultRankCap": 50,\n      "maxRankCap": 80,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_sr",\n      "metadata": "SR",\n      "defaultExperience": 0,\n      "defaultRankCap": 40,\n      "maxRankCap": 70,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "character_r",\n      "metadata": "R",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 60,\n      "rankThreshold": {\n        "metadata": "CHARACTER",\n        "values": [\n          100,\n          200,\n          300,\n          400,\n          500,\n          600,\n          700,\n          800,\n          900,\n          1000,\n          1100,\n          1200,\n          1300,\n          1400,\n          1500,\n          1600,\n          1700,\n          1800,\n          1900,\n          2000,\n          2100,\n          2200,\n          2300,\n          2400,\n          2500,\n          2600,\n          2700,\n          2800,\n          2900,\n          3000,\n          3100,\n          3200,\n          3300,\n          3400,\n          3500,\n          3600,\n          3700,\n          3800,\n          3900,\n          4000,\n          4100,\n          4200,\n          4300,\n          4400,\n          4500,\n          4600,\n          4700,\n          4800,\n          4900,\n          5000,\n          5100,\n          5200,\n          5300,\n          5400,\n          5500,\n          5600,\n          5700,\n          5800,\n          5900,\n          6000,\n          6100,\n          6200,\n          6300,\n          6400,\n          6500,\n          6600,\n          6700,\n          6800,\n          6900,\n          7000,\n          7100,\n          7200,\n          7300,\n          7400,\n          7500,\n          7600,\n          7700,\n          7800,\n          7900\n        ]\n      }\n    },\n    {\n      "name": "equipment",\n      "metadata": "EQUIPMENT",\n      "defaultExperience": 0,\n      "defaultRankCap": 30,\n      "maxRankCap": 50,\n      "rankThreshold": {\n        "metadata": "EQUIPMENT",\n        "values": [\n          200,\n          400,\n          600,\n          800,\n          1000,\n          1200,\n          1400,\n          1600,\n          1800,\n          2000,\n          2200,\n          2400,\n          2600,\n          2800,\n          3000,\n          3200,\n          3400,\n          3600,\n          3800,\n          4000,\n          4200,\n          4400,\n          4600,\n          4800,\n          5000,\n          5200,\n          5400,\n          5600,\n          5800,\n          6000,\n          6200,\n          6400,\n          6600,\n          6800,\n          7000,\n          7200,\n          7400,\n          7600,\n          7800,\n          8000,\n          8200,\n          8400,\n          8600,\n          8800,\n          9000,\n          9200,\n          9400,\n          9600,\n          9800\n        ]\n      }\n    },\n    {\n      "name": "skill",\n      "metadata": "SKILL",\n      "defaultExperience": 0,\n      "defaultRankCap": 10,\n      "maxRankCap": 20,\n      "rankThreshold": {\n        "metadata": "SKILL",\n        "values": [\n          300,\n          600,\n          900,\n          1200,\n          1500,\n          1800,\n          2100,\n          2400,\n          2700,\n          3000,\n          3300,\n          3600,\n          3900,\n          4200,\n          4500,\n          4800,\n          5100,\n          5400,\n          5700\n        ]\n      }\n    }\n  ]\n}"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Experience::CurrentExperienceMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効な経験値設定を更新します

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentExperienceMaster 更新した現在有効な経験値設定

updateCurrentExperienceMasterFromGitHub

同期処理

from gs2_experience_client.request import UpdateCurrentExperienceMasterFromGitHubRequest
from gs2_experience_client.result import UpdateCurrentExperienceMasterFromGitHubResult

result = client.update_current_experience_master_from_git_hub(
    UpdateCurrentExperienceMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.UpdateCurrentExperienceMasterFromGitHubRequest
import io.gs2.experience.result.UpdateCurrentExperienceMasterFromGitHubResult

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

非同期処理

from gs2_experience_client.request import UpdateCurrentExperienceMasterFromGitHubRequest
from gs2_experience_client.result import UpdateCurrentExperienceMasterFromGitHubResult

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

result = client.update_current_experience_master_from_git_hub_async(
    UpdateCurrentExperienceMasterFromGitHubRequest()\
    callback
)
import io.gs2.experience.request.UpdateCurrentExperienceMasterFromGitHubRequest
import io.gs2.experience.result.UpdateCurrentExperienceMasterFromGitHubResult

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

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

現在有効な経験値設定を更新します

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

updateExperienceModelMaster

同期処理

from gs2_experience_client.request import UpdateExperienceModelMasterRequest
from gs2_experience_client.result import UpdateExperienceModelMasterResult

result = client.update_experience_model_master(
    UpdateExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_experience_name('experience-model-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_default_experience(100)\
        .with_default_rank_cap(60)\
        .with_max_rank_cap(80)\
        .with_rank_threshold_id(threshold2['thresholdId'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.UpdateExperienceModelMasterRequest
import io.gs2.experience.result.UpdateExperienceModelMasterResult

result = client.updateExperienceModelMaster(
    UpdateExperienceModelMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withExperienceName("experience-model-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withDefaultExperience(100l)
        .withDefaultRankCap(60l)
        .withMaxRankCap(80l)
        .withRankThresholdId(threshold2.get'ThresholdId())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import UpdateExperienceModelMasterRequest
from gs2_experience_client.result import UpdateExperienceModelMasterResult

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

result = client.update_experience_model_master_async(
    UpdateExperienceModelMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_experience_name('experience-model-0001')\
        .with_description('description1')\
        .with_metadata('{"hoge": "fuga"}')\
        .with_default_experience(100)\
        .with_default_rank_cap(60)\
        .with_max_rank_cap(80)\
        .with_rank_threshold_id(threshold2['thresholdId']),
    callback
)
import io.gs2.experience.request.UpdateExperienceModelMasterRequest
import io.gs2.experience.result.UpdateExperienceModelMasterResult

result = client.updateExperienceModelMaster(
    UpdateExperienceModelMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withExperienceName("experience-model-0001")
        .withDescription("description1")
        .withMetadata("{"hoge": "fuga"}")
        .withDefaultExperience(100l)
        .withDefaultRankCap(60l)
        .withMaxRankCap(80l)
        .withRankThresholdId(threshold2.get'ThresholdId()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

経験値の種類マスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
experienceName string true 経験値の種類名
description string false 経験値の種類マスターの説明
metadata string false 経験値の種類のメタデータ
defaultExperience long true 経験値の初期値
defaultRankCap long true ランクキャップの初期値
maxRankCap long true ランクキャップの最大値
rankThresholdId string true ランク計算に用いる
パラメータ データ型 説明
item ExperienceModelMaster 更新した経験値の種類マスター

updateNamespace

同期処理

from gs2_experience_client.request import UpdateNamespaceRequest
from gs2_experience_client.result import UpdateNamespaceResult

result = client.update_namespace(
    UpdateNamespaceRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_description('description1')\
        .with_change_experience_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003'}))\
        .with_change_rank_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005'}))\
        .with_change_rank_cap_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007'}))\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'}))
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.UpdateNamespaceRequest
import io.gs2.experience.result.UpdateNamespaceResult

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

非同期処理

from gs2_experience_client.request import UpdateNamespaceRequest
from gs2_experience_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('namespaceId-0001')\
        .with_description('description1')\
        .with_change_experience_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003'}))\
        .with_change_rank_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005'}))\
        .with_change_rank_cap_script(Object("ScriptSetting", {"triggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006', "doneTriggerScriptId": 'grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007'}))\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.experience.request.UpdateNamespaceRequest
import io.gs2.experience.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("namespaceId-0001")
        .withDescription("description1")
        .withChangeExperienceScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1002", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1003"}))
        .withChangeRankScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1004", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1005"}))
        .withChangeRankCapScript(Object("ScriptSetting", {"triggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1006", "doneTriggerScriptId": "grn:gs2:ap-northeast-1:{ownerId}:script:namespace-0001:script:script-1007"}))
        .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 ネームスペースの説明
experienceCapScriptId string false ランクキャップ取得時 に実行されるスクリプト のGRN
changeExperienceScript ScriptSetting false 経験値変化したときに実行するスクリプト
changeRankScript ScriptSetting false ランク変化したときに実行するスクリプト
changeRankCapScript ScriptSetting false ランクキャップ変化したときに実行するスクリプト
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したネームスペース

updateThresholdMaster

同期処理

from gs2_experience_client.request import UpdateThresholdMasterRequest
from gs2_experience_client.result import UpdateThresholdMasterResult

result = client.update_threshold_master(
    UpdateThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_threshold_name('threshold-0001')\
        .with_description('description1')\
        .with_metadata('{"fuga": "piyo"}')\
        .with_values([
1100,   
1200,   
1300
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.experience.request.UpdateThresholdMasterRequest
import io.gs2.experience.result.UpdateThresholdMasterResult

result = client.updateThresholdMaster(
    UpdateThresholdMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withThresholdName("threshold-0001")
        .withDescription("description1")
        .withMetadata("{"fuga": "piyo"}")
        .withValues(new [] {
1100l,  
1200l,  
1300l
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_experience_client.request import UpdateThresholdMasterRequest
from gs2_experience_client.result import UpdateThresholdMasterResult

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

result = client.update_threshold_master_async(
    UpdateThresholdMasterRequest()\
        .with_namespace_name('namespaceId-0001')\
        .with_threshold_name('threshold-0001')\
        .with_description('description1')\
        .with_metadata('{"fuga": "piyo"}')\
        .with_values([
1100,   
1200,   
1300
]),
    callback
)
import io.gs2.experience.request.UpdateThresholdMasterRequest
import io.gs2.experience.result.UpdateThresholdMasterResult

result = client.updateThresholdMaster(
    UpdateThresholdMasterRequest()
        .withNamespaceName("namespaceId-0001")
        .withThresholdName("threshold-0001")
        .withDescription("description1")
        .withMetadata("{"fuga": "piyo"}")
        .withValues(new [] {
1100l,  
1200l,  
1300l
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ランクアップ閾値マスターを更新

パラメータ データ型 必須 説明
namespaceName string true ネームスペース名
thresholdName string true ランクアップ閾値名
description string false ランクアップ閾値マスターの説明
metadata string false ランクアップ閾値のメタデータ
values list[long] true ランクアップ経験値閾値リスト
パラメータ データ型 説明
item ThresholdMaster 更新したランクアップ閾値マスター

GS2-Script トリガーイベント

RankCapScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
experience_model = args['experienceModel']  -- type: ExperienceModel
statuses = args['statuses']  -- type: list[Status]

result = {
    rankCap=  -- type: integer
}

ランクキャップ取得時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
experienceModel ExperienceModel 経験値・ランクアップ閾値モデル
statuses list[Status] ステータスのリスト
パラメータ データ型 説明
rankCap integer ランクキャップ

ChangeExperienceTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
experience_model = args['experienceModel']  -- type: ExperienceModel
status = args['status']  -- type: Status

result = {
    permit=,  -- type: boolean
    overrideExperienceValue=  -- type: integer
}

経験値変化時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
experienceModel ExperienceModel 経験値・ランクアップ閾値モデル
status Status ステータス
パラメータ データ型 説明
permit boolean 経験値変化 を許可するか
overrideExperienceValue integer 経験値変化量

ChangeExperienceDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
experience_model = args['experienceModel']  -- type: ExperienceModel
status = args['status']  -- type: Status

result = {
}

経験値変化完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
experienceModel ExperienceModel 経験値・ランクアップ閾値モデル
status Status ステータス
パラメータ データ型 説明

ChangeRankTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
experience_model = args['experienceModel']  -- type: ExperienceModel
status = args['status']  -- type: Status

result = {
}

ランク変化時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
experienceModel ExperienceModel 経験値・ランクアップ閾値モデル
status Status ステータス
パラメータ データ型 説明

ChangeRankCapTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
experience_model = args['experienceModel']  -- type: ExperienceModel
status = args['status']  -- type: Status

result = {
    permit=,  -- type: boolean
    overrideRankCapValue=  -- type: integer
}

ランクキャップ変化時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
experienceModel ExperienceModel 経験値・ランクアップ閾値モデル
status Status ステータス
パラメータ データ型 説明
permit boolean ランクキャップ変化 を許可するか
overrideRankCapValue integer 新しいランクキャップ

ChangeRankCapDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
experience_model = args['experienceModel']  -- type: ExperienceModel
status = args['status']  -- type: Status

result = {
}

レベルキャップ変化完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace ネームスペース
experienceModel ExperienceModel 経験値・ランクアップ閾値モデル
status Status ステータス
パラメータ データ型 説明

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

CurrentExperienceMaster

{
  "version": "2019-01-11"
  "experienceModels": [
    {
      "name": "[string] 経験値の種類名",
      "metadata": "[string] 経験値の種類のメタデータ",
      "defaultExperience": "[long] 経験値の初期値",
      "defaultRankCap": "[long] ランクキャップの初期値",
      "maxRankCap": "[long] ランクキャップの最大値",
      "rankThreshold": [
        {
          "metadata": "[string] ランクアップ閾値のメタデータ",
          "values": 
          ["[long] ランクアップ経験値閾値"
          ]
        }
      ]
    }
  ]
}

現在有効な経験値設定

エクスポートしたマスターデータを、現在有効な経験値設定としてインポートして使用します。

GS2-Experience の制限・制約

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