NAV Navbar
Python Java GS2-Formation
 

GS2-Quest

クエストの進捗管理をします。

クエストには開始するために必要な対価、クエストに成功したときの報酬、クエストに失敗したときの報酬 を設定できます。

クエストを開始するために必要な対価にはスタミナを消費する処理や、回数制限のカウンター上昇などを設定します。

クエストに成功したときの報酬は複数設定でき、クエスト開始時に抽選する際に使用する確率を設定できます。 これを使用することで、クエストとしては同じだが、通常コンテンツとレアエネミーが出現するコンテンツを出し分けることができます。 クエスト成功時の報酬には、キャラクターの経験値やアイテム、ゲーム内通貨などを設定します。

クエストに失敗したときの報酬とは、クエストに失敗したときに開始時に受け取った対価を返却する場合などに設定します。

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

モデル

Namespace

クエストを分類するカテゴリー

メインクエストとサブクエストの管理を分けたりするのに使用します。

パラメータ データ型 必須 説明
namespaceId string true クエストを分類するカテゴリー
ownerId string true オーナーID
name string true カテゴリ名
description string false ネームスペースの説明
startQuestScript ScriptSetting false クエスト開始したときに実行するスクリプト
completeQuestScript ScriptSetting false クエストクリアしたときに実行するスクリプト
failedQuestScript ScriptSetting false クエスト失敗したときに実行するスクリプト
queueNamespaceId string false 報酬付与処理をジョブとして追加するキューのネームスペース のGRN
keyId string true 報酬付与処理のスタンプシートで使用する暗号鍵GRN
logSetting LogSetting false ログの出力設定
createdAt long true 作成日時
updatedAt long true 最終更新日時

QuestGroupModelMaster

クエストグループマスター

クエストを一定数で束ねる単位です。クリア済みのクエストリストなどはこのグループ単位でまとめて取得できます。 1つのクエストグループには最大1000個のクエストを設定できます。 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
questGroupModelId string true クエストグループマスター
name string true クエストグループモデル名
description string false クエストグループマスターの説明
metadata string false クエストグループのメタデータ
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
createdAt long true 作成日時
updatedAt long true 最終更新日時

QuestModelMaster

クエストモデルマスター

クエストの対価や報酬を設定 このモデルはマスターデータを管理するもので、最終的にはエクスポートして利用します。

パラメータ データ型 必須 説明
questModelId string true クエストモデルマスター
questGroupName string true クエストモデル名
name string true クエスト名
description string false クエストモデルの説明
metadata string false クエストのメタデータ
contents list[Contents] true クエストの内容
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
consumeActions list[ConsumeAction] false クエストの参加料
failedAcquireActions list[AcquireAction] false クエスト失敗時の報酬
premiseQuestNames list[string] false クエストに挑戦するためにクリアしておく必要のあるクエスト名
createdAt long true 作成日時
updatedAt long true 最終更新日時

CurrentQuestMaster

現在有効なクエストマスター

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

パラメータ データ型 必須 説明
namespaceId string true クエストを分類するカテゴリー
settings string true マスターデータ

ResponseCache

レスポンスキャッシュ

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

Contents

コンテンツ

パラメータ データ型 必須 説明
metadata string false クエストモデルのメタデータ
completeAcquireActions list[AcquireAction] false クエストクリア時の報酬
weight integer true 抽選する重み

ConsumeAction

消費アクション

パラメータ データ型 必須 説明
action string true スタンプタスクで実行するアクションの種類
request string true 消費リクエストのJSON

AcquireAction

入手アクション

パラメータ データ型 必須 説明
action string true スタンプシートで実行するアクションの種類
request string true 入手リクエストのJSON

Reward

クリア報酬

パラメータ データ型 必須 説明
action string true スタンプシートで実行するアクションの種類
request string true リクエストモデル
itemId string true 入手するリソースGRN
value integer true 入手する数量

Config

設定値

パラメータ データ型 必須 説明
key string false 名前
value string false

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

Progress

クエスト挑戦

挑戦中のクエストを管理するモデル。

パラメータ データ型 必須 説明
progressId string true クエスト挑戦
userId string true ユーザーID
transactionId string true トランザクションID
questModelId string true クエストモデル
randomSeed long true 乱数シード
rewards list[Reward] true クエストで得られる報酬の上限
createdAt long true 作成日時
updatedAt long true 最終更新日時

CompletedQuestList

クエスト進行

プレイヤーごとにクリア済みのクエストのリストを保持します。

パラメータ データ型 必須 説明
completedQuestListId string true クエスト進行
userId string false ユーザーID
questGroupName string false クエストグループ名
completeQuestNames list[string] true 攻略済みのクエスト名一覧のリスト
createdAt long true 作成日時
updatedAt long true 最終更新日時

QuestGroupModel

クエストグループ

クエストを一定数で束ねる単位です。クリア済みのクエストリストなどはこのグループ単位でまとめて取得できます。 1つのクエストグループには最大1000個のクエストを設定できます。

パラメータ データ型 必須 説明
questGroupModelId string true クエストグループ
name string true クエストグループ名
metadata string false クエストグループのメタデータ
quests list[QuestModel] false グループに属するクエスト
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN

QuestModel

None

パラメータ データ型 必須 説明
questModelId string true クエストモデル
name string true クエストモデル名
metadata string false クエストモデルのメタデータ
contents list[Contents] true クエストの内容
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
consumeActions list[ConsumeAction] false クエストの参加料
failedAcquireActions list[AcquireAction] false クエスト失敗時の報酬
premiseQuestNames list[string] false クエストに挑戦するためにクリアしておく必要のあるクエスト名

初期化処理

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

import gs2_core_client.model.*
import gs2_quest_client.rest.*

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

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

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

import gs2_core_client.model.*
import gs2_quest_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 = Gs2QuestRestClient(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.quest.rest.Gs2QuestRestClient

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

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

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

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

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

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

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

import gs2_core_client.model.*
import gs2_quest_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 = Gs2QuestWebSocketClient(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.quest.webSocket.Gs2QuestWebSocketClient

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

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

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

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

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

終了処理

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

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

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

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

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

メソッド

createNamespace

同期処理

from gs2_quest_client.request import CreateNamespaceRequest
from gs2_quest_client.result import CreateNamespaceResult

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

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

非同期処理

from gs2_quest_client.request import CreateNamespaceRequest
from gs2_quest_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('category-0001')\
        .with_queue_namespace_id('grn:gs2:{region}:{ownerId}:queue:queue-0001')\
        .with_key_id('grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0001')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.quest.request.CreateNamespaceRequest
import io.gs2.quest.result.CreateNamespaceResult

result = client.createNamespace(
    CreateNamespaceRequest()
        .withName("category-0001")
        .withQueueNamespaceId("grn:gs2:{region}:{ownerId}:queue:queue-0001")
        .withKeyId("grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-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::Quest::Namespace
Properties:
  Name: String
  Description: Optional[String]
  StartQuestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  CompleteQuestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  FailedQuestScript:
    TriggerScriptId: Optional[String]
    DoneTriggerScriptId: Optional[String]
    DoneTriggerQueueNamespaceId: Optional[String]
  QueueNamespaceId: Optional[String]
  KeyId: String
  LogSetting:
    LoggingNamespaceId: Optional[String]

クエストを分類するカテゴリーを新規作成

パラメータ データ型 必須 説明
name string true カテゴリ名
description string false ネームスペースの説明
startQuestScript ScriptSetting false クエスト開始したときに実行するスクリプト
completeQuestScript ScriptSetting false クエストクリアしたときに実行するスクリプト
failedQuestScript ScriptSetting false クエスト失敗したときに実行するスクリプト
queueNamespaceId string false 報酬付与処理をジョブとして追加するキューのネームスペース のGRN
keyId string true 報酬付与処理のスタンプシートで使用する暗号鍵GRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 作成したクエストを分類するカテゴリー

createProgressByStampSheet

同期処理

from gs2_quest_client.request import CreateProgressByStampSheetRequest
from gs2_quest_client.result import CreateProgressByStampSheetResult

result = client.create_progress_by_stamp_sheet(
    CreateProgressByStampSheetRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.CreateProgressByStampSheetRequest
import io.gs2.quest.result.CreateProgressByStampSheetResult

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

非同期処理

from gs2_quest_client.request import CreateProgressByStampSheetRequest
from gs2_quest_client.result import CreateProgressByStampSheetResult

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

result = client.create_progress_by_stamp_sheet_async(
    CreateProgressByStampSheetRequest()\
    callback
)
import io.gs2.quest.request.CreateProgressByStampSheetRequest
import io.gs2.quest.result.CreateProgressByStampSheetResult

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

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

スタンプシートでクエストを開始

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

createProgressByUserId

同期処理

from gs2_quest_client.request import CreateProgressByUserIdRequest
from gs2_quest_client.result import CreateProgressByUserIdResult

result = client.create_progress_by_user_id(
    CreateProgressByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.CreateProgressByUserIdRequest
import io.gs2.quest.result.CreateProgressByUserIdResult

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

非同期処理

from gs2_quest_client.request import CreateProgressByUserIdRequest
from gs2_quest_client.result import CreateProgressByUserIdResult

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

result = client.create_progress_by_user_id_async(
    CreateProgressByUserIdRequest()\
    callback
)
import io.gs2.quest.request.CreateProgressByUserIdRequest
import io.gs2.quest.result.CreateProgressByUserIdResult

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

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

ユーザIDを指定してクエスト挑戦を作成

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
userId string true ユーザーID
questModelId string true クエストモデル
force boolean true すでに開始しているクエストがある場合にそれを破棄して開始するか
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
item Progress クエスト挑戦

createQuestGroupModelMaster

同期処理

from gs2_quest_client.request import CreateQuestGroupModelMasterRequest
from gs2_quest_client.result import CreateQuestGroupModelMasterResult

result = client.create_quest_group_model_master(
    CreateQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_name('quest-group-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.CreateQuestGroupModelMasterRequest
import io.gs2.quest.result.CreateQuestGroupModelMasterResult

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

非同期処理

from gs2_quest_client.request import CreateQuestGroupModelMasterRequest
from gs2_quest_client.result import CreateQuestGroupModelMasterResult

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

result = client.create_quest_group_model_master_async(
    CreateQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_name('quest-group-0001'),
    callback
)
import io.gs2.quest.request.CreateQuestGroupModelMasterRequest
import io.gs2.quest.result.CreateQuestGroupModelMasterResult

result = client.createQuestGroupModelMaster(
    CreateQuestGroupModelMasterRequest()
        .withNamespaceName("category-0001")
        .withName("quest-group-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Quest::QuestGroupModelMaster
Properties:
  NamespaceName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  ChallengePeriodEventId: Optional[String]

クエストグループマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
name string true クエストグループモデル名
description string false クエストグループマスターの説明
metadata string false クエストグループのメタデータ
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
パラメータ データ型 説明
item QuestGroupModelMaster 作成したクエストグループマスター

createQuestModelMaster

同期処理

from gs2_quest_client.request import CreateQuestModelMasterRequest
from gs2_quest_client.result import CreateQuestModelMasterResult

result = client.create_quest_model_master(
    CreateQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_name('quest-0001')\
        .with_contents([
Object("Contents", {"metadata": 'normal', "completeAcquireActions": [
Object("AcquireAction", {"action": 'Gs2Experience:AddExperienceByUserId', "request": 'Gs2Experience:AddExperienceByUserId-request1'})
], "weight": 1})
])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.CreateQuestModelMasterRequest
import io.gs2.quest.result.CreateQuestModelMasterResult

result = client.createQuestModelMaster(
    CreateQuestModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withName("quest-0001")
        .withContents(new [] {
Object("Contents", {"metadata": "normal", "completeAcquireActions": new [] {
Object("AcquireAction", {"action": "Gs2Experience:AddExperienceByUserId", "request": "Gs2Experience:AddExperienceByUserId-request1"})
}, "weight": 1})
})
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_quest_client.request import CreateQuestModelMasterRequest
from gs2_quest_client.result import CreateQuestModelMasterResult

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

result = client.create_quest_model_master_async(
    CreateQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_name('quest-0001')\
        .with_contents([
Object("Contents", {"metadata": 'normal', "completeAcquireActions": [
Object("AcquireAction", {"action": 'Gs2Experience:AddExperienceByUserId', "request": 'Gs2Experience:AddExperienceByUserId-request1'})
], "weight": 1})
]),
    callback
)
import io.gs2.quest.request.CreateQuestModelMasterRequest
import io.gs2.quest.result.CreateQuestModelMasterResult

result = client.createQuestModelMaster(
    CreateQuestModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withName("quest-0001")
        .withContents(new [] {
Object("Contents", {"metadata": "normal", "completeAcquireActions": new [] {
Object("AcquireAction", {"action": "Gs2Experience:AddExperienceByUserId", "request": "Gs2Experience:AddExperienceByUserId-request1"})
}, "weight": 1})
}),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Quest::QuestModelMaster
Properties:
  NamespaceName: String
  QuestGroupName: String
  Name: String
  Description: Optional[String]
  Metadata: Optional[String]
  Contents:
    -
      Metadata: Optional[String]
      CompleteAcquireActions:
        - AcquireAction
        - AcquireAction
      Weight: Integer
    -
      Metadata: Optional[String]
      CompleteAcquireActions:
        - AcquireAction
        - AcquireAction
      Weight: Integer
  ChallengePeriodEventId: Optional[String]
  ConsumeActions:
    -
      Action: String
      Request: String
    -
      Action: String
      Request: String
  FailedAcquireActions:
    -
      Action: String
      Request: String
    -
      Action: String
      Request: String
  PremiseQuestNames:
    - String
    - String

クエストモデルマスターを新規作成

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
name string true クエスト名
description string false クエストモデルの説明
metadata string false クエストのメタデータ
contents list[Contents] true クエストの内容
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
consumeActions list[ConsumeAction] false クエストの参加料
failedAcquireActions list[AcquireAction] false クエスト失敗時の報酬
premiseQuestNames list[string] false クエストに挑戦するためにクリアしておく必要のあるクエスト名
パラメータ データ型 説明
item QuestModelMaster 作成したクエストモデルマスター

deleteCompletedQuestListByUserId

同期処理

from gs2_quest_client.request import DeleteCompletedQuestListByUserIdRequest
from gs2_quest_client.result import DeleteCompletedQuestListByUserIdResult

result = client.delete_completed_quest_list_by_user_id(
    DeleteCompletedQuestListByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name(quest_group1['name'])\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DeleteCompletedQuestListByUserIdRequest
import io.gs2.quest.result.DeleteCompletedQuestListByUserIdResult

result = client.deleteCompletedQuestListByUserId(
    DeleteCompletedQuestListByUserIdRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName(quest_group1.get'Name())
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_quest_client.request import DeleteCompletedQuestListByUserIdRequest
from gs2_quest_client.result import DeleteCompletedQuestListByUserIdResult

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

result = client.delete_completed_quest_list_by_user_id_async(
    DeleteCompletedQuestListByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name(quest_group1['name'])\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.quest.request.DeleteCompletedQuestListByUserIdRequest
import io.gs2.quest.result.DeleteCompletedQuestListByUserIdResult

result = client.deleteCompletedQuestListByUserId(
    DeleteCompletedQuestListByUserIdRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName(quest_group1.get'Name())
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザIDを指定してクエスト進行を削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
userId string false ユーザーID
パラメータ データ型 説明
item CompletedQuestList クエスト進行

deleteNamespace

同期処理

from gs2_quest_client.request import DeleteNamespaceRequest
from gs2_quest_client.result import DeleteNamespaceResult

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

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

非同期処理

from gs2_quest_client.request import DeleteNamespaceRequest
from gs2_quest_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('category-0001'),
    callback
)
import io.gs2.quest.request.DeleteNamespaceRequest
import io.gs2.quest.result.DeleteNamespaceResult

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

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

クエストを分類するカテゴリーを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
item Namespace 削除したクエストを分類するカテゴリー

deleteProgress

同期処理

from gs2_quest_client.request import DeleteProgressRequest
from gs2_quest_client.result import DeleteProgressResult

result = client.delete_progress(
    DeleteProgressRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DeleteProgressRequest
import io.gs2.quest.result.DeleteProgressResult

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

非同期処理

from gs2_quest_client.request import DeleteProgressRequest
from gs2_quest_client.result import DeleteProgressResult

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

result = client.delete_progress_async(
    DeleteProgressRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.quest.request.DeleteProgressRequest
import io.gs2.quest.result.DeleteProgressResult

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

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

クエスト挑戦を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
item Progress クエスト挑戦

deleteProgressByStampTask

同期処理

from gs2_quest_client.request import DeleteProgressByStampTaskRequest
from gs2_quest_client.result import DeleteProgressByStampTaskResult

result = client.delete_progress_by_stamp_task(
    DeleteProgressByStampTaskRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DeleteProgressByStampTaskRequest
import io.gs2.quest.result.DeleteProgressByStampTaskResult

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

非同期処理

from gs2_quest_client.request import DeleteProgressByStampTaskRequest
from gs2_quest_client.result import DeleteProgressByStampTaskResult

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

result = client.delete_progress_by_stamp_task_async(
    DeleteProgressByStampTaskRequest()\
    callback
)
import io.gs2.quest.request.DeleteProgressByStampTaskRequest
import io.gs2.quest.result.DeleteProgressByStampTaskResult

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

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

スタンプタスクで クエスト挑戦 を削除

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

deleteProgressByUserId

同期処理

from gs2_quest_client.request import DeleteProgressByUserIdRequest
from gs2_quest_client.result import DeleteProgressByUserIdResult

result = client.delete_progress_by_user_id(
    DeleteProgressByUserIdRequest()\
        .with_namespace_name('category-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DeleteProgressByUserIdRequest
import io.gs2.quest.result.DeleteProgressByUserIdResult

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

非同期処理

from gs2_quest_client.request import DeleteProgressByUserIdRequest
from gs2_quest_client.result import DeleteProgressByUserIdResult

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

result = client.delete_progress_by_user_id_async(
    DeleteProgressByUserIdRequest()\
        .with_namespace_name('category-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.quest.request.DeleteProgressByUserIdRequest
import io.gs2.quest.result.DeleteProgressByUserIdResult

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

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

ユーザIDを指定してクエスト挑戦を削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
userId string true ユーザーID
パラメータ データ型 説明
item Progress クエスト挑戦

deleteQuestGroupModelMaster

同期処理

from gs2_quest_client.request import DeleteQuestGroupModelMasterRequest
from gs2_quest_client.result import DeleteQuestGroupModelMasterResult

result = client.delete_quest_group_model_master(
    DeleteQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DeleteQuestGroupModelMasterRequest
import io.gs2.quest.result.DeleteQuestGroupModelMasterResult

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

非同期処理

from gs2_quest_client.request import DeleteQuestGroupModelMasterRequest
from gs2_quest_client.result import DeleteQuestGroupModelMasterResult

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

result = client.delete_quest_group_model_master_async(
    DeleteQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001'),
    callback
)
import io.gs2.quest.request.DeleteQuestGroupModelMasterRequest
import io.gs2.quest.result.DeleteQuestGroupModelMasterResult

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

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

クエストグループマスターを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
パラメータ データ型 説明
item QuestGroupModelMaster 削除したクエストグループマスター

deleteQuestModelMaster

同期処理

from gs2_quest_client.request import DeleteQuestModelMasterRequest
from gs2_quest_client.result import DeleteQuestModelMasterResult

result = client.delete_quest_model_master(
    DeleteQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_quest_name('quest-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DeleteQuestModelMasterRequest
import io.gs2.quest.result.DeleteQuestModelMasterResult

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

非同期処理

from gs2_quest_client.request import DeleteQuestModelMasterRequest
from gs2_quest_client.result import DeleteQuestModelMasterResult

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

result = client.delete_quest_model_master_async(
    DeleteQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_quest_name('quest-0001'),
    callback
)
import io.gs2.quest.request.DeleteQuestModelMasterRequest
import io.gs2.quest.result.DeleteQuestModelMasterResult

result = client.deleteQuestModelMaster(
    DeleteQuestModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withQuestName("quest-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

クエストモデルマスターを削除

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
questName string true クエスト名
パラメータ データ型 説明
item QuestModelMaster 削除したクエストモデルマスター

describeCompletedQuestLists

同期処理

from gs2_quest_client.request import DescribeCompletedQuestListsRequest
from gs2_quest_client.result import DescribeCompletedQuestListsResult

result = client.describe_completed_quest_lists(
    DescribeCompletedQuestListsRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeCompletedQuestListsRequest
import io.gs2.quest.result.DescribeCompletedQuestListsResult

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

非同期処理

from gs2_quest_client.request import DescribeCompletedQuestListsRequest
from gs2_quest_client.result import DescribeCompletedQuestListsResult

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

result = client.describe_completed_quest_lists_async(
    DescribeCompletedQuestListsRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.quest.request.DescribeCompletedQuestListsRequest
import io.gs2.quest.result.DescribeCompletedQuestListsResult

result = client.describeCompletedQuestLists(
    DescribeCompletedQuestListsRequest()
        .withNamespaceName("category-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[CompletedQuestList] クエスト進行のリスト
nextPageToken string リストの続きを取得するためのページトークン

describeCompletedQuestListsByUserId

同期処理

from gs2_quest_client.request import DescribeCompletedQuestListsByUserIdRequest
from gs2_quest_client.result import DescribeCompletedQuestListsByUserIdResult

result = client.describe_completed_quest_lists_by_user_id(
    DescribeCompletedQuestListsByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeCompletedQuestListsByUserIdRequest
import io.gs2.quest.result.DescribeCompletedQuestListsByUserIdResult

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

非同期処理

from gs2_quest_client.request import DescribeCompletedQuestListsByUserIdRequest
from gs2_quest_client.result import DescribeCompletedQuestListsByUserIdResult

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

result = client.describe_completed_quest_lists_by_user_id_async(
    DescribeCompletedQuestListsByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.quest.request.DescribeCompletedQuestListsByUserIdRequest
import io.gs2.quest.result.DescribeCompletedQuestListsByUserIdResult

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

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

ユーザIDを指定してクエスト進行の一覧を取得

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

describeNamespaces

同期処理

from gs2_quest_client.request import DescribeNamespacesRequest
from gs2_quest_client.result import DescribeNamespacesResult

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

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

非同期処理

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

describeProgressesByUserId

同期処理

from gs2_quest_client.request import DescribeProgressesByUserIdRequest
from gs2_quest_client.result import DescribeProgressesByUserIdResult

result = client.describe_progresses_by_user_id(
    DescribeProgressesByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeProgressesByUserIdRequest
import io.gs2.quest.result.DescribeProgressesByUserIdResult

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

非同期処理

from gs2_quest_client.request import DescribeProgressesByUserIdRequest
from gs2_quest_client.result import DescribeProgressesByUserIdResult

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

result = client.describe_progresses_by_user_id_async(
    DescribeProgressesByUserIdRequest()\
    callback
)
import io.gs2.quest.request.DescribeProgressesByUserIdRequest
import io.gs2.quest.result.DescribeProgressesByUserIdResult

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

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

クエスト挑戦の一覧を取得

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

describeQuestGroupModelMasters

同期処理

from gs2_quest_client.request import DescribeQuestGroupModelMastersRequest
from gs2_quest_client.result import DescribeQuestGroupModelMastersResult

result = client.describe_quest_group_model_masters(
    DescribeQuestGroupModelMastersRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeQuestGroupModelMastersRequest
import io.gs2.quest.result.DescribeQuestGroupModelMastersResult

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

非同期処理

from gs2_quest_client.request import DescribeQuestGroupModelMastersRequest
from gs2_quest_client.result import DescribeQuestGroupModelMastersResult

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

result = client.describe_quest_group_model_masters_async(
    DescribeQuestGroupModelMastersRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.quest.request.DescribeQuestGroupModelMastersRequest
import io.gs2.quest.result.DescribeQuestGroupModelMastersResult

result = client.describeQuestGroupModelMasters(
    DescribeQuestGroupModelMastersRequest()
        .withNamespaceName("category-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[QuestGroupModelMaster] クエストグループマスターのリスト
nextPageToken string リストの続きを取得するためのページトークン

describeQuestGroupModels

同期処理

from gs2_quest_client.request import DescribeQuestGroupModelsRequest
from gs2_quest_client.result import DescribeQuestGroupModelsResult

result = client.describe_quest_group_models(
    DescribeQuestGroupModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeQuestGroupModelsRequest
import io.gs2.quest.result.DescribeQuestGroupModelsResult

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

非同期処理

from gs2_quest_client.request import DescribeQuestGroupModelsRequest
from gs2_quest_client.result import DescribeQuestGroupModelsResult

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

result = client.describe_quest_group_models_async(
    DescribeQuestGroupModelsRequest()\
    callback
)
import io.gs2.quest.request.DescribeQuestGroupModelsRequest
import io.gs2.quest.result.DescribeQuestGroupModelsResult

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

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

クエストグループの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
items list[QuestGroupModel] クエストグループのリスト

describeQuestModelMasters

同期処理

from gs2_quest_client.request import DescribeQuestModelMastersRequest
from gs2_quest_client.result import DescribeQuestModelMastersResult

result = client.describe_quest_model_masters(
    DescribeQuestModelMastersRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeQuestModelMastersRequest
import io.gs2.quest.result.DescribeQuestModelMastersResult

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

非同期処理

from gs2_quest_client.request import DescribeQuestModelMastersRequest
from gs2_quest_client.result import DescribeQuestModelMastersResult

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

result = client.describe_quest_model_masters_async(
    DescribeQuestModelMastersRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001'),
    callback
)
import io.gs2.quest.request.DescribeQuestModelMastersRequest
import io.gs2.quest.result.DescribeQuestModelMastersResult

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

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

クエストモデルマスターの一覧を取得

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

describeQuestModels

同期処理

from gs2_quest_client.request import DescribeQuestModelsRequest
from gs2_quest_client.result import DescribeQuestModelsResult

result = client.describe_quest_models(
    DescribeQuestModelsRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.DescribeQuestModelsRequest
import io.gs2.quest.result.DescribeQuestModelsResult

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

非同期処理

from gs2_quest_client.request import DescribeQuestModelsRequest
from gs2_quest_client.result import DescribeQuestModelsResult

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

result = client.describe_quest_models_async(
    DescribeQuestModelsRequest()\
    callback
)
import io.gs2.quest.request.DescribeQuestModelsRequest
import io.gs2.quest.result.DescribeQuestModelsResult

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

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

クエストモデルの一覧を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
パラメータ データ型 説明
items list[QuestModel] Noneのリスト

end

同期処理

from gs2_quest_client.request import EndRequest
from gs2_quest_client.result import EndResult

result = client.end(
    EndRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.EndRequest
import io.gs2.quest.result.EndResult

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

非同期処理

from gs2_quest_client.request import EndRequest
from gs2_quest_client.result import EndResult

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

result = client.end_async(
    EndRequest()\
    callback
)
import io.gs2.quest.request.EndRequest
import io.gs2.quest.result.EndResult

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

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

クエストを完了

開始時に受け取ったクエストにおいて入手可能な報酬とその数量の"最大値"のうち、クエスト内で実際に入手した報酬を rewards で報告します。 isComplete にはクエストをクリアできたかを報告します。クエストに失敗した場合、rewards の値は無視してクエストに設定された失敗した場合の報酬が付与されます。

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
transactionId string true トランザクションID
rewards list[Reward] false 実際にクエストで得た報酬
isComplete boolean false クエストをクリアしたか
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
item Progress クエスト挑戦
stampSheet string 報酬付与処理の実行に使用するスタンプシート

endByUserId

同期処理

from gs2_quest_client.request import EndByUserIdRequest
from gs2_quest_client.result import EndByUserIdResult

result = client.end_by_user_id(
    EndByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.EndByUserIdRequest
import io.gs2.quest.result.EndByUserIdResult

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

非同期処理

from gs2_quest_client.request import EndByUserIdRequest
from gs2_quest_client.result import EndByUserIdResult

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

result = client.end_by_user_id_async(
    EndByUserIdRequest()\
    callback
)
import io.gs2.quest.request.EndByUserIdRequest
import io.gs2.quest.result.EndByUserIdResult

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

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

ユーザIDを指定してクエストを完了

開始時に受け取ったクエストにおいて入手可能な報酬とその数量の"最大値"のうち、クエスト内で実際に入手した報酬を rewards で報告します。 isComplete にはクエストをクリアできたかを報告します。クエストに失敗した場合、rewards の値は無視してクエストに設定された失敗した場合の報酬が付与されます。

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
userId string true ユーザーID
transactionId string true トランザクションID
rewards list[Reward] false 実際にクエストで得た報酬
isComplete boolean false クエストをクリアしたか
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
item Progress クエスト挑戦
stampSheet string 報酬付与処理の実行に使用するスタンプシート

exportMaster

同期処理

from gs2_quest_client.request import ExportMasterRequest
from gs2_quest_client.result import ExportMasterResult

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

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

非同期処理

from gs2_quest_client.request import ExportMasterRequest
from gs2_quest_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.quest.request.ExportMasterRequest
import io.gs2.quest.result.ExportMasterResult

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

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

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

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
item CurrentQuestMaster 現在有効なクエストマスター

getCompletedQuestList

同期処理

from gs2_quest_client.request import GetCompletedQuestListRequest
from gs2_quest_client.result import GetCompletedQuestListResult

result = client.get_completed_quest_list(
    GetCompletedQuestListRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name(quest_group1['name'])
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetCompletedQuestListRequest
import io.gs2.quest.result.GetCompletedQuestListResult

result = client.getCompletedQuestList(
    GetCompletedQuestListRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName(quest_group1.get'Name())
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_quest_client.request import GetCompletedQuestListRequest
from gs2_quest_client.result import GetCompletedQuestListResult

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

result = client.get_completed_quest_list_async(
    GetCompletedQuestListRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name(quest_group1['name']),
    callback
)
import io.gs2.quest.request.GetCompletedQuestListRequest
import io.gs2.quest.result.GetCompletedQuestListResult

result = client.getCompletedQuestList(
    GetCompletedQuestListRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName(quest_group1.get'Name()),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

クエスト進行を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
パラメータ データ型 説明
item CompletedQuestList クエスト進行

getCompletedQuestListByUserId

同期処理

from gs2_quest_client.request import GetCompletedQuestListByUserIdRequest
from gs2_quest_client.result import GetCompletedQuestListByUserIdResult

result = client.get_completed_quest_list_by_user_id(
    GetCompletedQuestListByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name(quest_group2['name'])\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetCompletedQuestListByUserIdRequest
import io.gs2.quest.result.GetCompletedQuestListByUserIdResult

result = client.getCompletedQuestListByUserId(
    GetCompletedQuestListByUserIdRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName(quest_group2.get'Name())
        .withUserId("user-0001")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_quest_client.request import GetCompletedQuestListByUserIdRequest
from gs2_quest_client.result import GetCompletedQuestListByUserIdResult

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

result = client.get_completed_quest_list_by_user_id_async(
    GetCompletedQuestListByUserIdRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name(quest_group2['name'])\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.quest.request.GetCompletedQuestListByUserIdRequest
import io.gs2.quest.result.GetCompletedQuestListByUserIdResult

result = client.getCompletedQuestListByUserId(
    GetCompletedQuestListByUserIdRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName(quest_group2.get'Name())
        .withUserId("user-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

ユーザIDを指定してクエスト進行を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
userId string false ユーザーID
パラメータ データ型 説明
item CompletedQuestList クエスト進行

getCurrentQuestMaster

同期処理

from gs2_quest_client.request import GetCurrentQuestMasterRequest
from gs2_quest_client.result import GetCurrentQuestMasterResult

result = client.get_current_quest_master(
    GetCurrentQuestMasterRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetCurrentQuestMasterRequest
import io.gs2.quest.result.GetCurrentQuestMasterResult

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

非同期処理

from gs2_quest_client.request import GetCurrentQuestMasterRequest
from gs2_quest_client.result import GetCurrentQuestMasterResult

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

result = client.get_current_quest_master_async(
    GetCurrentQuestMasterRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.quest.request.GetCurrentQuestMasterRequest
import io.gs2.quest.result.GetCurrentQuestMasterResult

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

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

現在有効なクエストマスターを取得します

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
item CurrentQuestMaster 現在有効なクエストマスター

getNamespace

同期処理

from gs2_quest_client.request import GetNamespaceRequest
from gs2_quest_client.result import GetNamespaceResult

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

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

非同期処理

from gs2_quest_client.request import GetNamespaceRequest
from gs2_quest_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('category-0001'),
    callback
)
import io.gs2.quest.request.GetNamespaceRequest
import io.gs2.quest.result.GetNamespaceResult

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

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

クエストを分類するカテゴリーを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
item Namespace クエストを分類するカテゴリー

getNamespaceStatus

同期処理

from gs2_quest_client.request import GetNamespaceStatusRequest
from gs2_quest_client.result import GetNamespaceStatusResult

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

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

非同期処理

from gs2_quest_client.request import GetNamespaceStatusRequest
from gs2_quest_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('category-0001'),
    callback
)
import io.gs2.quest.request.GetNamespaceStatusRequest
import io.gs2.quest.result.GetNamespaceStatusResult

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

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

クエストを分類するカテゴリーの状態を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
status string

getProgress

同期処理

from gs2_quest_client.request import GetProgressRequest
from gs2_quest_client.result import GetProgressResult

result = client.get_progress(
    GetProgressRequest()\
        .with_namespace_name('category-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetProgressRequest
import io.gs2.quest.result.GetProgressResult

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

非同期処理

from gs2_quest_client.request import GetProgressRequest
from gs2_quest_client.result import GetProgressResult

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

result = client.get_progress_async(
    GetProgressRequest()\
        .with_namespace_name('category-0001'),
    callback
)
import io.gs2.quest.request.GetProgressRequest
import io.gs2.quest.result.GetProgressResult

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

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

クエスト挑戦を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
パラメータ データ型 説明
item Progress クエスト挑戦
questGroup QuestGroupModel クエストグループ
quest QuestModel クエストモデル

getProgressByUserId

同期処理

from gs2_quest_client.request import GetProgressByUserIdRequest
from gs2_quest_client.result import GetProgressByUserIdResult

result = client.get_progress_by_user_id(
    GetProgressByUserIdRequest()\
        .with_namespace_name('category-0002')\
        .with_user_id('user-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetProgressByUserIdRequest
import io.gs2.quest.result.GetProgressByUserIdResult

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

非同期処理

from gs2_quest_client.request import GetProgressByUserIdRequest
from gs2_quest_client.result import GetProgressByUserIdResult

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

result = client.get_progress_by_user_id_async(
    GetProgressByUserIdRequest()\
        .with_namespace_name('category-0002')\
        .with_user_id('user-0001'),
    callback
)
import io.gs2.quest.request.GetProgressByUserIdRequest
import io.gs2.quest.result.GetProgressByUserIdResult

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

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

ユーザIDを指定してクエスト挑戦を取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
userId string true ユーザーID
パラメータ データ型 説明
item Progress クエスト挑戦
questGroup QuestGroupModel クエストグループ
quest QuestModel クエストモデル

getQuestGroupModel

同期処理

from gs2_quest_client.request import GetQuestGroupModelRequest
from gs2_quest_client.result import GetQuestGroupModelResult

result = client.get_quest_group_model(
    GetQuestGroupModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetQuestGroupModelRequest
import io.gs2.quest.result.GetQuestGroupModelResult

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

非同期処理

from gs2_quest_client.request import GetQuestGroupModelRequest
from gs2_quest_client.result import GetQuestGroupModelResult

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

result = client.get_quest_group_model_async(
    GetQuestGroupModelRequest()\
    callback
)
import io.gs2.quest.request.GetQuestGroupModelRequest
import io.gs2.quest.result.GetQuestGroupModelResult

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

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

クエストグループを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
パラメータ データ型 説明
item QuestGroupModel クエストグループ

getQuestGroupModelMaster

同期処理

from gs2_quest_client.request import GetQuestGroupModelMasterRequest
from gs2_quest_client.result import GetQuestGroupModelMasterResult

result = client.get_quest_group_model_master(
    GetQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetQuestGroupModelMasterRequest
import io.gs2.quest.result.GetQuestGroupModelMasterResult

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

非同期処理

from gs2_quest_client.request import GetQuestGroupModelMasterRequest
from gs2_quest_client.result import GetQuestGroupModelMasterResult

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

result = client.get_quest_group_model_master_async(
    GetQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001'),
    callback
)
import io.gs2.quest.request.GetQuestGroupModelMasterRequest
import io.gs2.quest.result.GetQuestGroupModelMasterResult

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

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

クエストグループマスターを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
パラメータ データ型 説明
item QuestGroupModelMaster クエストグループマスター

getQuestModel

同期処理

from gs2_quest_client.request import GetQuestModelRequest
from gs2_quest_client.result import GetQuestModelResult

result = client.get_quest_model(
    GetQuestModelRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetQuestModelRequest
import io.gs2.quest.result.GetQuestModelResult

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

非同期処理

from gs2_quest_client.request import GetQuestModelRequest
from gs2_quest_client.result import GetQuestModelResult

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

result = client.get_quest_model_async(
    GetQuestModelRequest()\
    callback
)
import io.gs2.quest.request.GetQuestModelRequest
import io.gs2.quest.result.GetQuestModelResult

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

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

クエストモデルを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
questName string true クエスト名
パラメータ データ型 説明
item QuestModel

getQuestModelMaster

同期処理

from gs2_quest_client.request import GetQuestModelMasterRequest
from gs2_quest_client.result import GetQuestModelMasterResult

result = client.get_quest_model_master(
    GetQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_quest_name('quest-0001')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.GetQuestModelMasterRequest
import io.gs2.quest.result.GetQuestModelMasterResult

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

非同期処理

from gs2_quest_client.request import GetQuestModelMasterRequest
from gs2_quest_client.result import GetQuestModelMasterResult

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

result = client.get_quest_model_master_async(
    GetQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_quest_name('quest-0001'),
    callback
)
import io.gs2.quest.request.GetQuestModelMasterRequest
import io.gs2.quest.result.GetQuestModelMasterResult

result = client.getQuestModelMaster(
    GetQuestModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withQuestName("quest-0001"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

クエストモデルマスターを取得

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
questName string true クエスト名
パラメータ データ型 説明
item QuestModelMaster クエストモデルマスター

start

同期処理

from gs2_quest_client.request import StartRequest
from gs2_quest_client.result import StartResult

result = client.start(
    StartRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.StartRequest
import io.gs2.quest.result.StartResult

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

非同期処理

from gs2_quest_client.request import StartRequest
from gs2_quest_client.result import StartResult

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

result = client.start_async(
    StartRequest()\
    callback
)
import io.gs2.quest.request.StartRequest
import io.gs2.quest.result.StartResult

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

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

クエストを開始

同一カテゴリ内でゲームプレイヤーは同時に1つのクエストを実行できます。 すでに同一カテゴリ内で実行中のクエストがある場合、このAPIはエラーを返します。 進行中のクエストを取得するAPIを呼び出すことで、クエストを再開するために必要な情報を得ることができます。 強制的にクエストを開始するには force パラメータに true を指定することで強制的にクエストを開始できます。

クエストが正常に開始できた場合、Progress オブジェクトを応答します。 Progress オブジェクトはクエストを実行するために必要ないくつかの情報を応答します。

transactionId は実行中のクエスト固有のIDです。 クエストの完了報告にはこのIDを指定する必要があります。

randomSeed はクエストの内容を決定するために使用できる乱数シードです。 クエストを開始するたびに異なる乱数が払い出されますので、この値をシード値としてゲームを進行させることで クエスト中にアプリケーションを強制終了したとしても同一条件で再開することができます。

rewards にはこのクエストにおいて入手可能な報酬とその数量の"最大値"が得られます。 クエストの完了報告にも rewards を渡すことができ、そこでクエスト中に実際に入手したアイテムの数量を指定します。 詳細はクエストの完了報告APIのドキュメントを参照してください。

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループ名
questName string true クエストモデル名
force boolean true すでに開始しているクエストがある場合にそれを破棄して開始するか
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
stampSheet string クエストの開始処理の実行に使用するスタンプシート

startByUserId

同期処理

from gs2_quest_client.request import StartByUserIdRequest
from gs2_quest_client.result import StartByUserIdResult

result = client.start_by_user_id(
    StartByUserIdRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.StartByUserIdRequest
import io.gs2.quest.result.StartByUserIdResult

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

非同期処理

from gs2_quest_client.request import StartByUserIdRequest
from gs2_quest_client.result import StartByUserIdResult

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

result = client.start_by_user_id_async(
    StartByUserIdRequest()\
    callback
)
import io.gs2.quest.request.StartByUserIdRequest
import io.gs2.quest.result.StartByUserIdResult

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

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

ユーザIDを指定してクエストを開始

同一カテゴリ内でゲームプレイヤーは同時に1つのクエストを実行できます。 すでに同一カテゴリ内で実行中のクエストがある場合、このAPIはエラーを返します。 進行中のクエストを取得するAPIを呼び出すことで、クエストを再開するために必要な情報を得ることができます。 強制的にクエストを開始するには force パラメータに true を指定することで強制的にクエストを開始できます。

クエストが正常に開始できた場合、Progress オブジェクトを応答します。 Progress オブジェクトはクエストを実行するために必要ないくつかの情報を応答します。

transactionId は実行中のクエスト固有のIDです。 クエストの完了報告にはこのIDを指定する必要があります。

randomSeed はクエストの内容を決定するために使用できる乱数シードです。 クエストを開®®始するたびに異なる乱数が払い出されますので、この値をシード値としてゲームを進行させることで クエスト中にアプリケーションを強制終了したとしても同一条件で再開することができます。

rewards にはこのクエストにおいて入手可能な報酬とその数量の"最大値"が得られます。 クエストの完了報告にも rewards を渡すことができ、そこでクエスト中に実際に入手したアイテムの数量を指定します。 詳細はクエストの完了報告APIのドキュメントを参照してください。

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループ名
questName string true クエストモデル名
userId string true ユーザーID
force boolean true すでに開始しているクエストがある場合にそれを破棄して開始するか
config list[Config] false スタンプシートの変数に適用する設定値
パラメータ データ型 説明
stampSheet string クエストの開始処理の実行に使用するスタンプシート

updateCurrentQuestMaster

同期処理

from gs2_quest_client.request import UpdateCurrentQuestMasterRequest
from gs2_quest_client.result import UpdateCurrentQuestMasterResult

result = client.update_current_quest_master(
    UpdateCurrentQuestMasterRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.UpdateCurrentQuestMasterRequest
import io.gs2.quest.result.UpdateCurrentQuestMasterResult

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

非同期処理

from gs2_quest_client.request import UpdateCurrentQuestMasterRequest
from gs2_quest_client.result import UpdateCurrentQuestMasterResult

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

result = client.update_current_quest_master_async(
    UpdateCurrentQuestMasterRequest()\
    callback
)
import io.gs2.quest.request.UpdateCurrentQuestMasterRequest
import io.gs2.quest.result.UpdateCurrentQuestMasterResult

result = client.updateCurrentQuestMaster(
    UpdateCurrentQuestMasterRequest(),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)
Type: GS2::Quest::CurrentQuestMaster
Properties:
  NamespaceName: String
  Settings: String

現在有効なクエストマスターを更新します

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
settings string true マスターデータ
パラメータ データ型 説明
item CurrentQuestMaster 更新した現在有効なクエストマスター

updateCurrentQuestMasterFromGitHub

同期処理

from gs2_quest_client.request import UpdateCurrentQuestMasterFromGitHubRequest
from gs2_quest_client.result import UpdateCurrentQuestMasterFromGitHubResult

result = client.update_current_quest_master_from_git_hub(
    UpdateCurrentQuestMasterFromGitHubRequest()\
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.UpdateCurrentQuestMasterFromGitHubRequest
import io.gs2.quest.result.UpdateCurrentQuestMasterFromGitHubResult

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

非同期処理

from gs2_quest_client.request import UpdateCurrentQuestMasterFromGitHubRequest
from gs2_quest_client.result import UpdateCurrentQuestMasterFromGitHubResult

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

result = client.update_current_quest_master_from_git_hub_async(
    UpdateCurrentQuestMasterFromGitHubRequest()\
    callback
)
import io.gs2.quest.request.UpdateCurrentQuestMasterFromGitHubRequest
import io.gs2.quest.result.UpdateCurrentQuestMasterFromGitHubResult

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

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

現在有効なクエストマスターを更新します

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
checkoutSetting GitHubCheckoutSetting true GitHubからマスターデータをチェックアウトしてくる設定
パラメータ データ型 説明
item CurrentQuestMaster 更新した現在有効なクエストマスター

updateNamespace

同期処理

from gs2_quest_client.request import UpdateNamespaceRequest
from gs2_quest_client.result import UpdateNamespaceResult

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

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

非同期処理

from gs2_quest_client.request import UpdateNamespaceRequest
from gs2_quest_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('category-0001')\
        .with_description('description1')\
        .with_queue_namespace_id('grn:gs2:{region}:{ownerId}:queue:queue-0002')\
        .with_key_id('grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0002')\
        .with_log_setting(Object("LogSetting", {"loggingNamespaceId": 'grn:gs2:ap-northeast-1:{ownerId}:log:namespace-0001'})),
    callback
)
import io.gs2.quest.request.UpdateNamespaceRequest
import io.gs2.quest.result.UpdateNamespaceResult

result = client.updateNamespace(
    UpdateNamespaceRequest()
        .withNamespaceName("category-0001")
        .withDescription("description1")
        .withQueueNamespaceId("grn:gs2:{region}:{ownerId}:queue:queue-0002")
        .withKeyId("grn:gs2:{region}:{ownerId}:key:namespace-0001:key:key-0002")
        .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 ネームスペースの説明
startQuestScript ScriptSetting false クエスト開始したときに実行するスクリプト
completeQuestScript ScriptSetting false クエストクリアしたときに実行するスクリプト
failedQuestScript ScriptSetting false クエスト失敗したときに実行するスクリプト
queueNamespaceId string false 報酬付与処理をジョブとして追加するキューのネームスペース のGRN
keyId string true 報酬付与処理のスタンプシートで使用する暗号鍵GRN
logSetting LogSetting false ログの出力設定
パラメータ データ型 説明
item Namespace 更新したクエストを分類するカテゴリー

updateQuestGroupModelMaster

同期処理

from gs2_quest_client.request import UpdateQuestGroupModelMasterRequest
from gs2_quest_client.result import UpdateQuestGroupModelMasterResult

result = client.update_quest_group_model_master(
    UpdateQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_description('description1')\
        .with_challenge_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.UpdateQuestGroupModelMasterRequest
import io.gs2.quest.result.UpdateQuestGroupModelMasterResult

result = client.updateQuestGroupModelMaster(
    UpdateQuestGroupModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withDescription("description1")
        .withChallengePeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_quest_client.request import UpdateQuestGroupModelMasterRequest
from gs2_quest_client.result import UpdateQuestGroupModelMasterResult

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

result = client.update_quest_group_model_master_async(
    UpdateQuestGroupModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_description('description1')\
        .with_challenge_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002'),
    callback
)
import io.gs2.quest.request.UpdateQuestGroupModelMasterRequest
import io.gs2.quest.result.UpdateQuestGroupModelMasterResult

result = client.updateQuestGroupModelMaster(
    UpdateQuestGroupModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withDescription("description1")
        .withChallengePeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

クエストグループマスターを更新

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
description string false クエストグループマスターの説明
metadata string false クエストグループのメタデータ
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
パラメータ データ型 説明
item QuestGroupModelMaster 更新したクエストグループマスター

updateQuestModelMaster

同期処理

from gs2_quest_client.request import UpdateQuestModelMasterRequest
from gs2_quest_client.result import UpdateQuestModelMasterResult

result = client.update_quest_model_master(
    UpdateQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_quest_name('quest-0001')\
        .with_description('description1')\
        .with_contents([
Object("Contents", {"metadata": 'normal', "completeAcquireActions": [
Object("AcquireAction", {"action": 'Gs2Experience:AddExperienceByUserId', "request": 'Gs2Experience:AddExperienceByUserId-request1'})
], "weight": 1})
])\
        .with_challenge_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002')
)
# エラー発生時には例外が発生
# result が成功結果が格納
import io.gs2.quest.request.UpdateQuestModelMasterRequest
import io.gs2.quest.result.UpdateQuestModelMasterResult

result = client.updateQuestModelMaster(
    UpdateQuestModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withQuestName("quest-0001")
        .withDescription("description1")
        .withContents(new [] {
Object("Contents", {"metadata": "normal", "completeAcquireActions": new [] {
Object("AcquireAction", {"action": "Gs2Experience:AddExperienceByUserId", "request": "Gs2Experience:AddExperienceByUserId-request1"})
}, "weight": 1})
})
        .withChallengePeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002")
)
// エラー発生時には例外が発生
// result が成功結果が格納
同期APIは実装されていません

非同期処理

from gs2_quest_client.request import UpdateQuestModelMasterRequest
from gs2_quest_client.result import UpdateQuestModelMasterResult

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

result = client.update_quest_model_master_async(
    UpdateQuestModelMasterRequest()\
        .with_namespace_name('category-0001')\
        .with_quest_group_name('quest-group-0001')\
        .with_quest_name('quest-0001')\
        .with_description('description1')\
        .with_contents([
Object("Contents", {"metadata": 'normal', "completeAcquireActions": [
Object("AcquireAction", {"action": 'Gs2Experience:AddExperienceByUserId', "request": 'Gs2Experience:AddExperienceByUserId-request1'})
], "weight": 1})
])\
        .with_challenge_period_event_id('grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002'),
    callback
)
import io.gs2.quest.request.UpdateQuestModelMasterRequest
import io.gs2.quest.result.UpdateQuestModelMasterResult

result = client.updateQuestModelMaster(
    UpdateQuestModelMasterRequest()
        .withNamespaceName("category-0001")
        .withQuestGroupName("quest-group-0001")
        .withQuestName("quest-0001")
        .withDescription("description1")
        .withContents(new [] {
Object("Contents", {"metadata": "normal", "completeAcquireActions": new [] {
Object("AcquireAction", {"action": "Gs2Experience:AddExperienceByUserId", "request": "Gs2Experience:AddExperienceByUserId-request1"})
}, "weight": 1})
})
        .withChallengePeriodEventId("grn:gs2:{region}:{ownerId}:schedule:schedule-0001:event:event-0002"),
    (result) => {
        if (result.getError() != null) {
            // エラー発生時には result.getError() で例外を取得
            throw result.getError()
        }
        // result.getResult() で成功結果を取得
    }
)

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

クエストモデルマスターを更新

パラメータ データ型 必須 説明
namespaceName string true カテゴリ名
questGroupName string true クエストグループモデル名
questName string true クエスト名
description string false クエストモデルの説明
metadata string false クエストのメタデータ
contents list[Contents] true クエストの内容
challengePeriodEventId string false 挑戦可能な期間を指定するイベントマスター のGRN
consumeActions list[ConsumeAction] false クエストの参加料
failedAcquireActions list[AcquireAction] false クエスト失敗時の報酬
premiseQuestNames list[string] false クエストに挑戦するためにクリアしておく必要のあるクエスト名
パラメータ データ型 説明
item QuestModelMaster 更新したクエストモデルマスター

GS2-Script トリガーイベント

StartQuestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
quest_group_model = args['questGroupModel']  -- type: QuestGroupModel
quest_model = args['questModel']  -- type: QuestModel
random_seed = args['randomSeed']  -- type: long
rewards = args['rewards']  -- type: list[Reward]

result = {
    permit=,  -- type: boolean
    overrideRandomSeed=,  -- type: long
    overrideRewards=  -- type: list[Reward]
}

クエスト開始時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace クエストを分類するカテゴリー
questGroupModel QuestGroupModel クエストグループ
questModel QuestModel None
randomSeed long 乱数シード
rewards list[Reward] クエストで得られる報酬の上限
パラメータ データ型 説明
permit boolean クエスト開始を許可するか
overrideRandomSeed long 乱数シード
overrideRewards list[Reward] クエストで得られる報酬の上限

StartQuestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
quest_group_model = args['questGroupModel']  -- type: QuestGroupModel
quest_model = args['questModel']  -- type: QuestModel
progress = args['progress']  -- type: Progress

result = {
}

クエスト開始完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace クエストを分類するカテゴリー
questGroupModel QuestGroupModel クエストグループ
questModel QuestModel None
progress Progress クエスト挑戦
パラメータ データ型 説明

CompleteQuestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
quest_group_model = args['questGroupModel']  -- type: QuestGroupModel
quest_model = args['questModel']  -- type: QuestModel
rewards = args['rewards']  -- type: list[Reward]

result = {
    permit=,  -- type: boolean
    overrideRewards=  -- type: list[Reward]
}

クエストクリア時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace クエストを分類するカテゴリー
questGroupModel QuestGroupModel クエストグループ
questModel QuestModel None
rewards list[Reward] クエストで得た報酬
パラメータ データ型 説明
permit boolean クエストクリアを許可するか
overrideRewards list[Reward] クエストで得られる報酬の上限

CompleteQuestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
quest_group_model = args['questGroupModel']  -- type: QuestGroupModel
quest_model = args['questModel']  -- type: QuestModel
rewards = args['rewards']  -- type: list[Reward]

result = {
}

クエストクリア完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace クエストを分類するカテゴリー
questGroupModel QuestGroupModel クエストグループ
questModel QuestModel None
rewards list[Reward] クエストで得た報酬
パラメータ データ型 説明

FailedQuestTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
quest_group_model = args['questGroupModel']  -- type: QuestGroupModel
quest_model = args['questModel']  -- type: QuestModel
rewards = args['rewards']  -- type: list[Reward]

result = {
    permit=,  -- type: boolean
    overrideRewards=  -- type: list[Reward]
}

クエスト失敗時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace クエストを分類するカテゴリー
questGroupModel QuestGroupModel クエストグループ
questModel QuestModel None
rewards list[Reward] クエストで得た報酬
パラメータ データ型 説明
permit boolean クエスト失敗を許可するか
overrideRewards list[Reward] クエストで得られる報酬の上限

FailedQuestDoneTriggerScript

スクリプトの雛形

namespace = args['namespace']  -- type: Namespace
quest_group_model = args['questGroupModel']  -- type: QuestGroupModel
quest_model = args['questModel']  -- type: QuestModel
rewards = args['rewards']  -- type: list[Reward]

result = {
}

クエスト失敗完了時 に実行されるGS2-Script

パラメータ データ型 説明
namespace Namespace クエストを分類するカテゴリー
questGroupModel QuestGroupModel クエストグループ
questModel QuestModel None
rewards list[Reward] クエストで得た報酬
パラメータ データ型 説明

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

CurrentQuestMaster

{
  "version": "2019-05-14"
  "groups": [
    {
      "name": "[string] クエストグループ名",
      "metadata": "[string] クエストグループのメタデータ",
      "challengePeriodEventId": "[string] 挑戦可能な期間を指定するイベントマスター のGRN",
      "quests": [
        {
          "name": "[string] クエストモデル名",
          "metadata": "[string] クエストモデルのメタデータ",
          "challengePeriodEventId": "[string] 挑戦可能な期間を指定するイベントマスター のGRN",
          "premiseQuestNames": 
          ["[string] クエストモデル名"
          ]
        }
      ]
    }
  ]
}

現在有効なクエストマスター

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

GS2-Quest の制限・制約

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