> For the complete documentation index, see [llms.txt](/llms.txt)
# GS2-Inventory SDK for Game Engine API リファレンス
ゲームエンジン向け GS2-Inventory SDK の モデルの仕様 と API のリファレンス
## モデル
### EzInventory
インベントリ
インベントリは、ゲームプレイヤーが所有するアイテムを格納するためのカバンのようなものです。
カバンには容量があり、プレイヤーごとに容量を拡張することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| inventoryId | string | | ※ | | ~ 1024文字 | インベントリGRN
※ サーバーが自動で設定 |
| inventoryName | string | | ✓ | | ~ 128文字 | インベントリモデル名
このインベントリの構造と容量設定を定義するインベントリモデルの名前です。ユーザーのインベントリインスタンスをモデル定義にリンクし、使用可能なアイテムの種類と容量制限を決定します。 |
| currentInventoryCapacityUsage | int | | | 0 | 0 ~ 2147483646 | キャパシティ使用量
アイテムセットによって現在使用されているインベントリ枠の数です。新しいアイテムスタックが追加された時（例：allowMultipleStacksで新しい枠が作成された時）にインクリメントされ、アイテムセットが完全に消費または削除された時にデクリメントされます。currentInventoryMaxCapacityを超えることはできません。 |
| currentInventoryMaxCapacity | int | | ✓ | | 1 ~ 2147483646 | 最大キャパシティ
このユーザーが使用可能なインベントリ枠の現在の最大数です。インベントリモデルのinitialCapacityから初期化され、入手アクションまたは直接のAPI呼び出しを通じてモデルのmaxCapacityまで拡張できます。 |
**関連するメソッド:**
getInventory - 特定のインベントリの詳細を取得する
listInventories - プレイヤーのインベントリ一覧を取得する
consume - プレイヤーのインベントリからアイテムを消費する
getItem - インベントリ名とアイテム名を指定してアイテムを取得する
getItemWithSignature - 所持証明の署名付きでアイテムを取得する
---
### EzItemSet
アイテムセット
アイテムセットはゲームプレイヤーのインベントリ内に保存されている所有物を表しています。
インベントリモデル名とアイテムモデル名、所持数量、有効期限等を保持します。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| itemSetId | string | | ※ | | ~ 1024文字 | アイテムセットGRN
※ サーバーが自動で設定 |
| name | string | | ✓ | UUID | ~ 36文字 | アイテムセットを識別する名前
アイテムセットの一意な名前を保持します。
名前は UUID（Universally Unique Identifier）フォーマットで自動的に生成され、各アイテムセットを識別するために使用されます。 |
| inventoryName | string | | ✓ | | ~ 128文字 | インベントリモデル名
このアイテムセットを含むインベントリモデルの名前です。itemNameと組み合わせて、この所持品がどのインベントリとアイテムの種類に属するかを識別するために使用されます。 |
| itemName | string | | ✓ | | ~ 128文字 | アイテムモデル名
このセットに格納されているアイテムの種類を定義するアイテムモデルの名前です。inventoryNameと組み合わせて、このアイテムセットのスタック上限と複数スタック動作を決定します。 |
| count | long | | ✓ | | 1 ~ 9223372036854775805 | 所持数量
このスタック内のアイテム数です。1からアイテムモデルのスタック上限までの範囲です。アイテムを入手するとスタック上限までカウントが増加し、消費すると減少します。カウントが0になるとアイテムセットは削除され、インベントリ枠が解放されます。 |
| sortValue | int | | ✓ | | 0 ~ 2147483646 | 表示順番
アイテムモデルのsortValueからコピーされた数値で、インベントリ内のアイテムセットを表示用にソートするために使用されます。値が小さいほど先に表示されます。 |
| expiresAt | long | | | 0 | | 有効期限
UNIX 時間・ミリ秒 |
| referenceOf | List<string> | | | [] | 0 ~ 24 items | 参照元リスト
このアイテムセットに登録された外部参照です。どのシステムがこのアイテムを使用しているか（例：武器として装備、編成に割り当て）を追跡するために使用されます。アイテムセットあたり最大24参照です。 |
**関連するメソッド:**
consume - プレイヤーのインベントリからアイテムを消費する
getItem - インベントリ名とアイテム名を指定してアイテムを取得する
getItemWithSignature - 所持証明の署名付きでアイテムを取得する
listItems - インベントリ内のプレイヤーが所持するアイテム一覧を取得する
---
### EzSimpleItem
シンプルアイテム
シンプルアイテムはゲームプレイヤーのインベントリー内に保存されている所有物を表しています。
シンプルアイテムモデル名と所持数量を持ちます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| itemId | string | | ※ | | ~ 1024文字 | シンプルアイテムGRN
※ サーバーが自動で設定 |
| itemName | string | | ✓ | | ~ 128文字 | シンプルアイテムモデル名
このレコードに格納されているアイテムの種類を定義するシンプルアイテムモデルの名前です。この所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| count | long | | ✓ | | 0 ~ 9223372036854775805 | 所持数量
ユーザーが所持するこのアイテムの種類の数です。通常のインベントリアイテムと異なり、シンプルアイテムにはスタック上限がなく、カウントはint64の範囲内で任意の値を取ることができます。他のシンプルアイテムとともにバッチ操作で増減できます。 |
**関連するメソッド:**
consumeSimpleItems - プレイヤーのインベントリからシンプルアイテムを消費する
getSimpleItem - 特定のシンプルアイテムの所持数を取得する
getSimpleItemWithSignature - 所持証明の署名付きでシンプルアイテムを取得する
listSimpleItems - シンプルインベントリ内のプレイヤーが所持するアイテム一覧を取得する
---
### EzBigItem
巨大アイテム
巨大アイテムはゲームプレイヤーの巨大インベントリー内に保存されている所有物を表しています。
巨大アイテムモデル名と、所持数量をint64の範囲を超えて保持できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| itemId | string | | ※ | | ~ 1024文字 | 巨大アイテムGRN
※ サーバーが自動で設定 |
| itemName | string | | ✓ | | ~ 128文字 | 巨大アイテムモデル名
このレコードに格納されているアイテムの種類を定義する巨大アイテムモデルの名前です。この巨大アイテムの所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| count | string
BigInteger (Unity) | | ✓ | | ~ 1024文字 | 所持数量
最大1024桁までの整数値文字列 |
**関連するメソッド:**
consumeBigItem - プレイヤーのインベントリから巨大アイテムを消費する
getBigItem - 特定の巨大アイテムの所持数を取得する
listBigItems - 巨大インベントリ内のプレイヤーが所持するアイテム一覧を取得する
---
### EzInventoryModel
インベントリモデル
インベントリはゲームプレイヤーが所有しているアイテムを格納するカバンのようなものです。
インベントリには容量が設定でき、容量を超えては所有できません。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | インベントリモデル名
インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
| initialCapacity | int | | ✓ | | 0 ~ 2147483646 | 初期サイズ
インベントリが初めて作成される際にユーザーに提供されるインベントリ枠の数です。各枠には1つのアイテムスタックを格納できます。ユーザーはゲームプレイのアクションを通じてmaxCapacityまで容量を拡張できます。 |
| maxCapacity | int | | ✓ | | 0 ~ 2147483646 | 最大サイズ
ユーザーが拡張可能なインベントリ枠の上限値です。この値を超えて容量を増やすことはできません。すべての枠が使用中でアイテムをこれ以上スタックできない場合、オーバーフロースクリプトが超過分を処理しない限り、入手は失敗します。 |
**関連するメソッド:**
getInventoryModel - 名前を指定してインベントリタイプ定義を取得する
listInventoryModels - インベントリタイプ定義の一覧を取得する
---
### EzItemModel
アイテムモデル
アイテムは、ポーション ×99 のように、1つのインベントリ枠に複数個まとめて所持できます。
このように 1枠に複数個まとめることを「スタック」 と呼び、アイテムごとに スタックできる上限数 を設定できます。
スタック上限に達した場合の挙動もアイテムごとに設定できます。
具体的には、以下のどちらかを選べます：
- 新しいインベントリ枠を追加して、さらに所持できるようにする
- 上限に達したため、これ以上入手できないようにする
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | アイテムモデル名
アイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
GS2-EnhanceにはGS2-Inventoryと連携して強化を行う仕組みがあり、ItemModelのメタデータにJSON形式で、強化素材として使用した場合の経験値量を設定します。
詳細は [マイクロサービス紹介 / GS2-Enhance](/microservices/enhance/#強化レート) の項で解説しています。 |
| stackingLimit | long | | ✓ | | 1 ~ 9223372036854775805 | スタック可能な最大数量
1つのインベントリ枠（スタック）に保持できるこのアイテムの最大数です。この上限に達した場合の動作はallowMultipleStacks設定に依存し、新しい枠が割り当てられるか、それ以上の入手がブロックされます。 |
| allowMultipleStacks | bool | | ✓ | | | 複数スタック許可
有効にすると、スタック上限に達した場合に新しいインベントリ枠が自動的に割り当てられ、このアイテムの追加数量を格納します（追加の容量を消費します）。無効の場合、既存の枠でスタック上限に達すると入手がブロックされます。 |
| sortValue | int | | ✓ | | 0 ~ 2147483646 | 表示順番
インベントリ内のアイテムを表示用にソートするための数値です。値が小さいほど先に表示されます。この値はItemSetレコードにもコピーされ、所持アイテムの一貫した順序付けを可能にします。 |
**関連するメソッド:**
getItemModel - 名前を指定してアイテム定義を取得する
listItemModels - インベントリ内のアイテム定義の一覧を取得する
consume - プレイヤーのインベントリからアイテムを消費する
getItem - インベントリ名とアイテム名を指定してアイテムを取得する
getItemWithSignature - 所持証明の署名付きでアイテムを取得する
---
### EzSimpleInventoryModel
シンプルインベントリモデル
通常の InventoryModel では、インベントリ内に格納できるアイテムの容量制限ができました。
しかし、シンプルインベントリ ではそのような機能はなく、単純にアイテムの所持数量を保持するのみとなります。
ただし、シンプルインベントリでは、複数のアイテムの増減処理を1回の処理で実行可能なAPIが利用できます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
**関連するメソッド:**
getSimpleInventoryModel - 名前を指定してシンプルインベントリタイプ定義を取得する
listSimpleInventoryModels - シンプルインベントリタイプ定義の一覧を取得する
---
### EzSimpleItemModel
シンプルアイテムモデル
ItemModel では、スタックできる数量の最大値を設定でき、一定数を超える場合は複数のスタックに分けるような実装が可能でした。
シンプルアイテム にはそのような機能はなく、単純にアイテムの所持数量を保持するのみとなります。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | シンプルアイテムモデル名
シンプルアイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
**関連するメソッド:**
getSimpleItemModel - 名前を指定してシンプルアイテム定義を取得する
listSimpleItemModels - シンプルインベントリ内のアイテム定義の一覧を取得する
getSimpleItem - 特定のシンプルアイテムの所持数を取得する
getSimpleItemWithSignature - 所持証明の署名付きでシンプルアイテムを取得する
---
### EzBigInventoryModel
巨大インベントリモデル
通常の InventoryModel や SimpleInventoryModel では、インベントリに格納できるアイテムの数は int64 の範囲に限られました。
インフレ系ゲームでは、もっと広い値の範囲を必要とする場合があります。
巨大インベントリモデルでは、インベントリに格納できるアイテムの数には1024桁の整数値を持たせることができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
**関連するメソッド:**
getBigInventoryModel - 名前を指定して巨大インベントリタイプ定義を取得する
listBigInventoryModels - 巨大インベントリタイプ定義の一覧を取得する
---
### EzBigItemModel
巨大アイテムモデル
巨大アイテムモデルは、巨大インベントリモデルに格納される巨大アイテムを定義するモデルです。
巨大アイテムは、所持数量を int64 の範囲を超えて保持することができます。
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| name | string | | ✓ | | ~ 128文字 | 巨大アイテムモデル名
巨大アイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| metadata | string | | | | ~ 2048文字 | メタデータ
メタデータには任意の値を設定できます。
これらの値は GS2 の動作には影響しないため、ゲーム内で利用する情報の保存先として使用できます。 |
**関連するメソッド:**
getBigItemModel - 名前を指定して巨大アイテム定義を取得する
listBigItemModels - 巨大インベントリ内のアイテム定義の一覧を取得する
getBigItem - 特定の巨大アイテムの所持数を取得する
---
### EzConsumeCount
シンプルアイテムの消費数量
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| itemName | string | | ✓ | | ~ 128文字 | シンプルアイテムモデル名
このレコードに格納されているアイテムの種類を定義するシンプルアイテムモデルの名前です。この所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| count | long | | ✓ | | 1 ~ 9223372036854775805 | 消費する量 |
**関連するメソッド:**
consumeSimpleItems - プレイヤーのインベントリからシンプルアイテムを消費する
---
### EzAcquireCount
シンプルアイテムの入手数量
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| itemName | string | | ✓ | | ~ 128文字 | シンプルアイテムモデル名
このレコードに格納されているアイテムの種類を定義するシンプルアイテムモデルの名前です。この所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| count | long | | ✓ | | 1 ~ 9223372036854775805 | 入手する量 |
---
## メソッド
### getInventoryModel
名前を指定してインベントリタイプ定義を取得する
名前を指定して、インベントリモデルを1件取得します。
取得できる情報には、初期容量と最大容量、アイテム保護設定、このインベントリに属するすべてのアイテムモデルが含まれます。
特定のインベントリタイプの詳細を表示するのに使います。たとえば「装備バッグ — 容量: 50/100 — アイテム: 鉄の剣、鋼の盾、革の鎧…」のような表示に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzInventoryModel](#ezinventorymodel) | インベントリモデル|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->InventoryModel(
"item" // inventoryName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->InventoryModel(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listInventoryModels
インベントリタイプ定義の一覧を取得する
このネームスペースに登録されているすべてのインベントリモデルを取得します。
インベントリモデルは、アイテムを入れるコンテナの種類を定義します。「装備バッグ」「素材ポーチ」「消耗品ボックス」などです。
各モデルには初期容量と最大容量（何種類のアイテムを格納できるか）が設定されており、格納可能なアイテムモデルのリストも含まれます。
プレイヤーがどんな種類のインベントリを持っているかを表示するのに使います。たとえば「装備（50/100スロット）」「素材（30/200スロット）」のようなタブ表示に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzInventoryModel>](#ezinventorymodel) | インベントリモデルのリスト|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
var items = await domain.InventoryModelsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
var it = domain.InventoryModels(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
);
const auto It = Domain->InventoryModels(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeInventoryModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeInventoryModels(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeInventoryModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeInventoryModels(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeInventoryModels(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeInventoryModels(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getItemModel
名前を指定してアイテム定義を取得する
インベントリ名とアイテム名を指定して、アイテムモデルを1件取得します。
取得できる情報には、最大スタック数、複数スタックをサポートするか（例: 有効期限の異なるアイテムは別スタックに格納される）、ソート順が含まれます。
アイテムのルールを表示するのに使います。たとえば「回復ポーション — 1スタック最大: 99個 — 有効期限の異なるものは別スタックで保持」のような表示に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | アイテムモデル名
アイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzItemModel](#ezitemmodel) | |
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
).ItemModel(
itemName: "item-master-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
).ItemModel(
itemName: "item-master-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->InventoryModel(
"item" // inventoryName
)->ItemModel(
"item-master-0001" // itemName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
).ItemModel(
itemName: "item-master-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
).ItemModel(
itemName: "item-master-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->InventoryModel(
"item" // inventoryName
)->ItemModel(
"item-master-0001" // itemName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listItemModels
インベントリ内のアイテム定義の一覧を取得する
指定したインベントリに属するすべてのアイテムモデルを取得します。
アイテムモデルは特定のアイテムタイプのルールを定義します。最大スタック数（例: ポーションは99個まで重ねられる）、複数スタックに分割できるか、表示のソート順などです。
インベントリにどんな種類のアイテムが存在できるかを表示するのに使います。たとえば「装備バッグ」の全装備タイプや「素材ポーチ」の全素材を一覧表示する際に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzItemModel>](#ezitemmodel) | アイテムモデルのリスト|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
var items = await domain.ItemModelsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
var it = domain.ItemModels(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->InventoryModel(
"item" // inventoryName
);
const auto It = Domain->ItemModels(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeItemModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeItemModels(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).InventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeItemModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeItemModels(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->InventoryModel(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeItemModels(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeItemModels(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getInventory
特定のインベントリの詳細を取得する
名前を指定して、特定のインベントリの詳細を取得します。現在の容量使用状況（使用中スロット / 最大スロット）が含まれます。
特定のインベントリのステータスを表示するのに使います。たとえば、装備インベントリ画面の上部に「装備バッグ — 45 / 100スロット使用中」と表示するのに便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
このインベントリの構造と容量設定を定義するインベントリモデルの名前です。ユーザーのインベントリインスタンスをモデル定義にリンクし、使用可能なアイテムの種類と容量制限を決定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzInventory](#ezinventory) | インベントリ|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"inventory-0001" // inventoryName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"inventory-0001" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listInventories
プレイヤーのインベントリ一覧を取得する
プレイヤーが持つすべてのインベントリを取得します。
各インベントリには、現在の容量使用状況（最大容量のうち何種類のアイテム（スロット）が使用されているか）が含まれます。
インベントリの概要画面を構築するのに使います。たとえば「装備バッグ: 45/100スロット使用中」「素材ポーチ: 120/200スロット使用中」のように、プレイヤーのアイテムコンテナを一覧表示する画面に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzInventory>](#ezinventory) | インベントリのリスト|
| nextPageToken | string | リストの続きを取得するためのページトークン|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
);
var items = await domain.InventoriesAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
);
var it = domain.Inventories(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
);
const auto It = Domain->Inventories(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeInventories(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeInventories(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeInventories(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeInventories(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeInventories(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeInventories(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### consume
プレイヤーのインベントリからアイテムを消費する
プレイヤーのインベントリにある特定のアイテムの数量を減らします。ゲーム独自のロジックでプレイヤーがアイテムを使ったり消費したりする場合に使います。
たとえば、バトルで回復ポーションを使う、クラフト素材を消費する、カスタムのゲーム機能でアイテムを使うといった場合です。
注意: 商品の購入（GS2-Showcase）やクエストの開始（GS2-Quest）の対価としてアイテムを消費する場合は、それらのシステムが自動的に処理するため、このAPIを呼ぶ必要はありません。
どのスタック（itemSetName）から消費するかを指定することもできます。省略した場合、最も古いスタックから優先的に消費されます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
このアイテムセットを含むインベントリモデルの名前です。itemNameと組み合わせて、この所持品がどのインベントリとアイテムの種類に属するかを識別するために使用されます。 |
| itemName | string | | ✓| | ~ 128文字 | アイテムモデル名
このセットに格納されているアイテムの種類を定義するアイテムモデルの名前です。inventoryNameと組み合わせて、このアイテムセットのスタック上限と複数スタック動作を決定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| consumeCount | long | | ✓| | 1 ~ 9223372036854775805 | 消費する量 |
| itemSetName | string | | | | ~ 36文字 | アイテムセットを識別する名前 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzItemSet>](#ezitemset) | 消費後のアイテムセットのリスト|
| itemModel | [EzItemModel](#ezitemmodel) | アイテムモデル|
| inventory | [EzInventory](#ezinventory) | インベントリ|
#### Error
このAPIには特別な例外が定義されています。
GS2-SDK for Game Engine ではゲーム内でハンドリングが必要そうなエラーは一般的な例外から派生した特殊化した例外を用意することでハンドリングしやすくしています。
一般的なエラーの種類や、ハンドリング方法は [こちら]() のドキュメントを参考にしてください。
| 型 | 基底クラス | 説明 |
| --- | --- | --- |
| ConflictException | ConflictException | アイテムの操作処理が衝突しました。リトライが必要です |
| InsufficientException | BadRequestException | アイテムの所持数量が不足しています |
#### 実装例
**Unity (UniTask)**
```csharp
try {
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
).ItemSet(
itemName: "item-0001",
itemSetName: null
);
var result = await domain.ConsumeAsync(
consumeCount: 1L
);
var item = await result.ModelAsync();
} catch(Gs2.Gs2Inventory.Exception.ConflictException e) {
// Item manipulation process conflicted. Retry required.
} catch(Gs2.Gs2Inventory.Exception.InsufficientException e) {
// Insufficient quantity of items in your possession.
}
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
).ItemSet(
itemName: "item-0001",
itemSetName: null
);
var future = domain.ConsumeFuture(
consumeCount: 1L
);
yield return future;
if (future.Error != null)
{
if (future.Error is Gs2.Gs2Inventory.Exception.ConflictException)
{
// Item manipulation process conflicted. Retry required.
}
if (future.Error is Gs2.Gs2Inventory.Exception.InsufficientException)
{
// Insufficient quantity of items in your possession.
}
onError.Invoke(future.Error, null);
yield break;
}
var future2 = future.Result.ModelFuture();
yield return future2;
if (future2.Error != null)
{
onError.Invoke(future2.Error, null);
yield break;
}
var result = future2.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"inventory-0001" // inventoryName
)->ItemSet(
"item-0001", // itemName
nullptr // itemSetName
);
const auto Future = Domain->Consume(
1L // consumeCount
);
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
auto e = Future->GetTask().Error();
if (e->IsChildOf(Gs2::Inventory::Error::FConflictError::Class))
{
// Item manipulation process conflicted. Retry required.
}
if (e->IsChildOf(Gs2::Inventory::Error::FInsufficientError::Class))
{
// Insufficient quantity of items in your possession.
}
return false;
}
// obtain changed values / result values
const auto Future2 = Future->GetTask().Result()->Model();
Future2->StartSynchronousTask();
if (Future2->GetTask().IsError())
{
return Future2->GetTask().Error();
}
const auto Result = Future2->GetTask().Result();
```
---
### getItem
インベントリ名とアイテム名を指定してアイテムを取得する
指定したインベントリでプレイヤーが所持する特定のアイテムタイプのすべてのスタックを取得します。
同じアイテムでも複数のスタック（アイテムセット）として返されることがあります。有効期限の異なるアイテムは必ず別のスタックになります。
たとえば「回復ポーション」をリクエストすると、期限の近い50個のスタックと後で期限が来る30個のスタックの2つが返されることがあります。
アイテム詳細画面を表示するのに使います。たとえば「回復ポーション — 合計: 80個 — スタック1: 50個（期限 2024-03-01）、スタック2: 30個（期限 2024-03-15）」のような表示に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
このアイテムセットを含むインベントリモデルの名前です。itemNameと組み合わせて、この所持品がどのインベントリとアイテムの種類に属するかを識別するために使用されます。 |
| itemName | string | | ✓| | ~ 128文字 | アイテムモデル名
このセットに格納されているアイテムの種類を定義するアイテムモデルの名前です。inventoryNameと組み合わせて、このアイテムセットのスタック上限と複数スタック動作を決定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzItemSet>](#ezitemset) | アイテムセットのリスト|
| itemModel | [EzItemModel](#ezitemmodel) | アイテムモデル|
| inventory | [EzInventory](#ezinventory) | インベントリ|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
).ItemSet(
itemName: "item-0001",
itemSetName: "itemSet-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
).ItemSet(
itemName: "item-0001",
itemSetName: "itemSet-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"item" // inventoryName
)->ItemSet(
"item-0001", // itemName
"itemSet-0001" // itemSetName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
).ItemSet(
itemName: "item-0001",
itemSetName: "itemSet-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
).ItemSet(
itemName: "item-0001",
itemSetName: "itemSet-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"item" // inventoryName
)->ItemSet(
"item-0001", // itemName
"itemSet-0001" // itemSetName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getItemWithSignature
所持証明の署名付きでアイテムを取得する
アイテムセットと、プレイヤーがAPI呼び出し時点でこのアイテムを所持していたことを証明するサーバー署名を一緒に取得します。
外部サーバーや別のシステムでアイテムの所持を検証する必要がある場合に便利です。署名は改ざん防止の証拠として機能します。
たとえば、特別なダンジョンに入る前にプレイヤーが特定の武器を本当に所持しているかを検証するのに使えます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
このアイテムセットを含むインベントリモデルの名前です。itemNameと組み合わせて、この所持品がどのインベントリとアイテムの種類に属するかを識別するために使用されます。 |
| itemName | string | | ✓| | ~ 128文字 | アイテムモデル名
このセットに格納されているアイテムの種類を定義するアイテムモデルの名前です。inventoryNameと組み合わせて、このアイテムセットのスタック上限と複数スタック動作を決定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| itemSetName | string | | | | ~ 36文字 | アイテムセットを識別する名前 |
| keyId | string | | | "grn:gs2:{region}:{ownerId}:key:default:key:default" | ~ 1024文字 | 暗号鍵GRN |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzItemSet>](#ezitemset) | アイテムセットのリスト|
| itemModel | [EzItemModel](#ezitemmodel) | アイテムモデル|
| inventory | [EzInventory](#ezinventory) | インベントリ|
| body | string | 署名対象のアイテムセット情報|
| signature | string | 署名|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
).ItemSet(
itemName: "item-0001",
itemSetName: null
);
var result = await domain.GetItemWithSignatureAsync(
keyId: "key-0001"
);
var item = await result.ModelAsync();
var body = result.Body;
var signature = result.Signature;
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "inventory-0001"
).ItemSet(
itemName: "item-0001",
itemSetName: null
);
var future = domain.GetItemWithSignatureFuture(
keyId: "key-0001"
);
yield return future;
if (future.Error != null)
{
onError.Invoke(future.Error, null);
yield break;
}
var future2 = future.Result.ModelFuture();
yield return future2;
if (future2.Error != null)
{
onError.Invoke(future2.Error, null);
yield break;
}
var result = future2.Result;
var body = future.Result.Body;
var signature = future.Result.Signature;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"inventory-0001" // inventoryName
)->ItemSet(
"item-0001", // itemName
nullptr // itemSetName
);
const auto Future = Domain->GetItemWithSignature(
"key-0001" // keyId
);
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
// obtain changed values / result values
const auto Future2 = Future->GetTask().Result()->Model();
Future2->StartSynchronousTask();
if (Future2->GetTask().IsError())
{
return Future2->GetTask().Error();
}
const auto Result = Future2->GetTask().Result();
const auto Body = Result->Body;
const auto Signature = Result->Signature;
```
---
### listItems
インベントリ内のプレイヤーが所持するアイテム一覧を取得する
指定したインベントリでプレイヤーが現在所持しているすべてのアイテムを取得します。
各エントリは「アイテムセット」で、数量とオプションの有効期限を持つアイテムのスタックです。同じアイテムタイプでも有効期限が異なる場合は複数のスタックとして表示されます。
たとえば「回復ポーション」が「回復ポーション x50（3日後に期限切れ）」と「回復ポーション x30（7日後に期限切れ）」の2つのエントリとして表示されることがあります。
インベントリのメインアイテムリスト画面を構築するのに使います。所持アイテムとその数量を一覧表示する画面です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | インベントリモデル名
インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzItemSet>](#ezitemset) | アイテムセットのリスト|
| nextPageToken | string | リストの続きを取得するためのページトークン|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
);
var items = await domain.ItemSetsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
);
var it = domain.ItemSets(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"item" // inventoryName
);
const auto It = Domain->ItemSets(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeItemSets(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeItemSets(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).Inventory(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeItemSets(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeItemSets(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->Inventory(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeItemSets(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeItemSets(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getSimpleInventoryModel
名前を指定してシンプルインベントリタイプ定義を取得する
名前を指定して、シンプルインベントリモデルを1件取得します。
取得できる情報には、このインベントリに属するシンプルアイテムモデルのリスト（格納できるアイテムとその属性の定義）が含まれます。
特定のシンプルインベントリの中身を表示するのに使います。たとえば「通貨」や「素材」インベントリに含まれるアイテムタイプを確認する際に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzSimpleInventoryModel](#ezsimpleinventorymodel) | シンプルインベントリモデル|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->SimpleInventoryModel(
"item" // inventoryName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->SimpleInventoryModel(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listSimpleInventoryModels
シンプルインベントリタイプ定義の一覧を取得する
このネームスペースに登録されているすべてのシンプルインベントリモデルを取得します。
シンプルインベントリは標準インベントリの軽量版で、スタック・有効期限・容量制限なしに、アイテムを名前と数量のシンプルなペアで管理します。
通貨、クラフト素材、数量だけ管理すればよいアイテムに最適です。たとえば「ゴールド: 5000」「鉄鉱石: 150」「スタミナポーション: 12」のような用途です。
ゲームでどんな種類のシンプルインベントリが使えるかを確認するのに使います。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzSimpleInventoryModel>](#ezsimpleinventorymodel) | シンプルインベントリモデルのリスト|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
var items = await domain.SimpleInventoryModelsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
var it = domain.SimpleInventoryModels(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
);
const auto It = Domain->SimpleInventoryModels(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeSimpleInventoryModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeSimpleInventoryModels(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeSimpleInventoryModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeSimpleInventoryModels(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeSimpleInventoryModels(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeSimpleInventoryModels(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getSimpleItemModel
名前を指定してシンプルアイテム定義を取得する
インベントリ名とアイテム名を指定して、シンプルアイテムモデルを1件取得します。
特定のシンプルアイテムタイプの定義を表示するのに使います。たとえば、ゲームUIで「ゴールド」や「鉄鉱石」の属性を表示する際に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | シンプルアイテムモデル名
シンプルアイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzSimpleItemModel](#ezsimpleitemmodel) | |
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
).SimpleItemModel(
itemName: "item-master-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
).SimpleItemModel(
itemName: "item-master-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->SimpleInventoryModel(
"item" // inventoryName
)->SimpleItemModel(
"item-master-0001" // itemName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
).SimpleItemModel(
itemName: "item-master-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
).SimpleItemModel(
itemName: "item-master-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->SimpleInventoryModel(
"item" // inventoryName
)->SimpleItemModel(
"item-master-0001" // itemName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listSimpleItemModels
シンプルインベントリ内のアイテム定義の一覧を取得する
指定したシンプルインベントリに属するすべてのシンプルアイテムモデルを取得します。
シンプルアイテムモデルは数量のみで管理されるアイテムタイプを定義します。スタックルールや有効期限はなく、名前と数値だけです。
シンプルインベントリにどんなアイテムが存在できるかを確認するのに使います。たとえば「素材」インベントリ内の「ゴールド」「ジェム」「鉄鉱石」「木材」を一覧表示する際に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzSimpleItemModel>](#ezsimpleitemmodel) | シンプルアイテムモデルのリスト|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
var items = await domain.SimpleItemModelsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
var it = domain.SimpleItemModels(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->SimpleInventoryModel(
"item" // inventoryName
);
const auto It = Domain->SimpleItemModels(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeSimpleItemModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeSimpleItemModels(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).SimpleInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeSimpleItemModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeSimpleItemModels(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->SimpleInventoryModel(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeSimpleItemModels(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeSimpleItemModels(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### consumeSimpleItems
プレイヤーのインベントリからシンプルアイテムを消費する
プレイヤーのインベントリにある1種類以上のシンプルアイテムの数量を減らします。1回の呼び出しで複数のアイテムタイプをまとめて消費できます。
ゲーム独自のロジックでプレイヤーがリソースを消費する場合に使います。たとえば、武器を鍛造するためのクラフト素材の消費や、バトルでの消耗品の使用などです。
注意: 商品の購入（GS2-Showcase）やクエストの開始（GS2-Quest）の対価としてアイテムを消費する場合は、それらのシステムが自動的に処理するため、このAPIを呼ぶ必要はありません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| consumeCounts | [List<EzConsumeCount>](#ezconsumecount) | | ✓| | 1 ~ 100 items | シンプルアイテムの消費数量のリスト |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzSimpleItem>](#ezsimpleitem) | 消費後のシンプルアイテムのリスト|
#### Error
このAPIには特別な例外が定義されています。
GS2-SDK for Game Engine ではゲーム内でハンドリングが必要そうなエラーは一般的な例外から派生した特殊化した例外を用意することでハンドリングしやすくしています。
一般的なエラーの種類や、ハンドリング方法は [こちら]() のドキュメントを参考にしてください。
| 型 | 基底クラス | 説明 |
| --- | --- | --- |
| ConflictException | ConflictException | アイテムの操作処理が衝突しました。リトライが必要です |
| InsufficientException | BadRequestException | アイテムの所持数量が不足しています |
#### 実装例
**Unity (UniTask)**
```csharp
try {
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "inventory-0001"
);
var result = await domain.ConsumeSimpleItemsAsync(
consumeCounts: new List {
new Gs2.Unity.Gs2Inventory.Model.EzConsumeCount() {
ItemName = "item-0001",
Count = 5,
},
new Gs2.Unity.Gs2Inventory.Model.EzConsumeCount() {
ItemName = "item-0002",
Count = 3,
},
}
);
var item = await result.ModelAsync();
} catch(Gs2.Gs2Inventory.Exception.ConflictException e) {
// Item manipulation process conflicted. Retry required.
} catch(Gs2.Gs2Inventory.Exception.InsufficientException e) {
// Insufficient quantity of items in your possession.
}
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "inventory-0001"
);
var future = domain.ConsumeSimpleItemsFuture(
consumeCounts: new List {
new Gs2.Unity.Gs2Inventory.Model.EzConsumeCount() {
ItemName = "item-0001",
Count = 5,
},
new Gs2.Unity.Gs2Inventory.Model.EzConsumeCount() {
ItemName = "item-0002",
Count = 3,
},
}
);
yield return future;
if (future.Error != null)
{
if (future.Error is Gs2.Gs2Inventory.Exception.ConflictException)
{
// Item manipulation process conflicted. Retry required.
}
if (future.Error is Gs2.Gs2Inventory.Exception.InsufficientException)
{
// Insufficient quantity of items in your possession.
}
onError.Invoke(future.Error, null);
yield break;
}
var future2 = future.Result.ModelFuture();
yield return future2;
if (future2.Error != null)
{
onError.Invoke(future2.Error, null);
yield break;
}
var result = future2.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->SimpleInventory(
"inventory-0001" // inventoryName
);
const auto Future = Domain->ConsumeSimpleItems(
[]
{
auto v = MakeShared>>();
v->Add(
MakeShared()
->WithItemName(TOptional("item-0001"))
->WithCount(TOptional(5))
);
v->Add(
MakeShared()
->WithItemName(TOptional("item-0002"))
->WithCount(TOptional(3))
);
return v;
}() // consumeCounts
);
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
auto e = Future->GetTask().Error();
if (e->IsChildOf(Gs2::Inventory::Error::FConflictError::Class))
{
// Item manipulation process conflicted. Retry required.
}
if (e->IsChildOf(Gs2::Inventory::Error::FInsufficientError::Class))
{
// Insufficient quantity of items in your possession.
}
return false;
}
// obtain changed values / result values
const auto Future2 = Future->GetTask().Result()->Model();
Future2->StartSynchronousTask();
if (Future2->GetTask().IsError())
{
return Future2->GetTask().Error();
}
const auto Result = Future2->GetTask().Result();
```
---
### getSimpleItem
特定のシンプルアイテムの所持数を取得する
プレイヤーが特定のシンプルアイテムを現在いくつ所持しているかを取得します。
特定のリソースの数量を確認するのに使います。たとえば、ショップ画面で購入前に「ゴールド: 5,000」と表示したり、クラフト画面で「鉄鉱石: 150/200個必要」と表示するのに便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | シンプルアイテムモデル名
このレコードに格納されているアイテムの種類を定義するシンプルアイテムモデルの名前です。この所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| gameSession | GameSession | | ✓| | | GameSession |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzSimpleItem](#ezsimpleitem) | シンプルアイテム|
| itemModel | [EzSimpleItemModel](#ezsimpleitemmodel) | シンプルアイテムモデル|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
).SimpleItem(
itemName: "item-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
).SimpleItem(
itemName: "item-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->SimpleInventory(
"item" // inventoryName
)->SimpleItem(
"item-0001" // itemName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
).SimpleItem(
itemName: "item-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
).SimpleItem(
itemName: "item-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->SimpleInventory(
"item" // inventoryName
)->SimpleItem(
"item-0001" // itemName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getSimpleItemWithSignature
所持証明の署名付きでシンプルアイテムを取得する
シンプルアイテムと、プレイヤーがAPI呼び出し時点でこのアイテムを所持していたことを証明するサーバー署名を一緒に取得します。
外部サーバーや別のシステムでアイテムの所持を検証する必要がある場合に便利です。署名は改ざん防止の証拠として機能します。
たとえば、外部マーケットプレイスでトレードを処理する前に、プレイヤーが十分な通貨や素材を持っているかを検証するのに使えます。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | シンプルアイテムモデル名
このレコードに格納されているアイテムの種類を定義するシンプルアイテムモデルの名前です。この所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| gameSession | GameSession | | ✓| | | GameSession |
| keyId | string | | | "grn:gs2:{region}:{ownerId}:key:default:key:default" | ~ 1024文字 | 暗号鍵GRN |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzSimpleItem](#ezsimpleitem) | シンプルアイテム|
| simpleItemModel | [EzSimpleItemModel](#ezsimpleitemmodel) | シンプルアイテムモデル|
| body | string | 署名対象のシンプルアイテム情報|
| signature | string | 署名|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "inventory-0001"
).SimpleItem(
itemName: "item-0001"
);
var result = await domain.GetSimpleItemWithSignatureAsync(
keyId: "key-0001"
);
var item = await result.ModelAsync();
var body = result.Body;
var signature = result.Signature;
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "inventory-0001"
).SimpleItem(
itemName: "item-0001"
);
var future = domain.GetSimpleItemWithSignatureFuture(
keyId: "key-0001"
);
yield return future;
if (future.Error != null)
{
onError.Invoke(future.Error, null);
yield break;
}
var future2 = future.Result.ModelFuture();
yield return future2;
if (future2.Error != null)
{
onError.Invoke(future2.Error, null);
yield break;
}
var result = future2.Result;
var body = future.Result.Body;
var signature = future.Result.Signature;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->SimpleInventory(
"inventory-0001" // inventoryName
)->SimpleItem(
"item-0001" // itemName
);
const auto Future = Domain->GetSimpleItemWithSignature(
"key-0001" // keyId
);
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
// obtain changed values / result values
const auto Future2 = Future->GetTask().Result()->Model();
Future2->StartSynchronousTask();
if (Future2->GetTask().IsError())
{
return Future2->GetTask().Error();
}
const auto Result = Future2->GetTask().Result();
const auto Body = Result->Body;
const auto Signature = Result->Signature;
```
---
### listSimpleItems
シンプルインベントリ内のプレイヤーが所持するアイテム一覧を取得する
指定したシンプルインベントリでプレイヤーが現在所持しているすべてのシンプルアイテムを取得します。
各アイテムは名前と数量のシンプルなペアです。たとえば「ゴールド: 5000」「鉄鉱石: 150」のような形式です。
標準インベントリのアイテムと違い、シンプルアイテムにはスタック・有効期限・スロット制限がありません。
リソースや素材のリストを表示するのに使います。たとえば、プレイヤーの通貨残高、クラフト素材、消耗品の数量を表示する画面に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | シンプルインベントリモデル名
シンプルインベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzSimpleItem>](#ezsimpleitem) | シンプルアイテムのリスト|
| nextPageToken | string | リストの続きを取得するためのページトークン|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
);
var items = await domain.SimpleItemsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
);
var it = domain.SimpleItems(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->SimpleInventory(
"item" // inventoryName
);
const auto It = Domain->SimpleItems(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeSimpleItems(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeSimpleItems(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).SimpleInventory(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeSimpleItems(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeSimpleItems(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->SimpleInventory(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeSimpleItems(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeSimpleItems(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getBigInventoryModel
名前を指定して巨大インベントリタイプ定義を取得する
名前を指定して、巨大インベントリモデルを1件取得します。
取得できる情報には、このインベントリに属する巨大アイテムモデルのリストが含まれます。
特定の巨大インベントリタイプの詳細を表示するのに使います。たとえば「メガ通貨」や「累積ポイント」インベントリで追跡されるアイテムを確認する際に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzBigInventoryModel](#ezbiginventorymodel) | 巨大インベントリモデル|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->BigInventoryModel(
"item" // inventoryName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->BigInventoryModel(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listBigInventoryModels
巨大インベントリタイプ定義の一覧を取得する
このネームスペースに登録されているすべての巨大インベントリモデルを取得します。
巨大インベントリは、通常の整数では扱えないほど非常に大きな数量を持つアイテムのために設計されています（例: 数十億、数兆）。
放置ゲーム/インクリメンタルゲームの通貨、累積ポイント、非常に大きな数に成長するリソースに便利です。
ゲームでどんな種類の巨大インベントリが使えるかを確認するのに使います。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzBigInventoryModel>](#ezbiginventorymodel) | 巨大インベントリモデルのリスト|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
var items = await domain.BigInventoryModelsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
var it = domain.BigInventoryModels(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
);
const auto It = Domain->BigInventoryModels(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeBigInventoryModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeBigInventoryModels(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeBigInventoryModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeBigInventoryModels(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeBigInventoryModels(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeBigInventoryModels(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### getBigItemModel
名前を指定して巨大アイテム定義を取得する
インベントリ名とアイテム名を指定して、巨大アイテムモデルを1件取得します。
特定の巨大アイテムタイプの定義を表示するのに使います。たとえば、ゲームUIで「メガゴールド」や「累計XP」の属性を表示する際に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | 巨大アイテムモデル名
巨大アイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzBigItemModel](#ezbigitemmodel) | |
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
).BigItemModel(
itemName: "item-master-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
).BigItemModel(
itemName: "item-master-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->BigInventoryModel(
"item" // inventoryName
)->BigItemModel(
"item-master-0001" // itemName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
).BigItemModel(
itemName: "item-master-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
).BigItemModel(
itemName: "item-master-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->BigInventoryModel(
"item" // inventoryName
)->BigItemModel(
"item-master-0001" // itemName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listBigItemModels
巨大インベントリ内のアイテム定義の一覧を取得する
指定した巨大インベントリに属するすべての巨大アイテムモデルを取得します。
巨大アイテムモデルは、任意精度の数値（整数ではなく文字列として格納）を使って非常に大きな数量を持てるアイテムタイプを定義します。
巨大インベントリにどんなアイテムが存在できるかを確認するのに使います。たとえば「メガゴールド」「累計XP」「総ダメージ量」などの一覧表示に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzBigItemModel>](#ezbigitemmodel) | 巨大アイテムモデルのリスト|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
var items = await domain.BigItemModelsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
var it = domain.BigItemModels(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->BigInventoryModel(
"item" // inventoryName
);
const auto It = Domain->BigItemModels(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeBigItemModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeBigItemModels(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).BigInventoryModel(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeBigItemModels(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeBigItemModels(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->BigInventoryModel(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeBigItemModels(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeBigItemModels(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### consumeBigItem
プレイヤーのインベントリから巨大アイテムを消費する
プレイヤーのインベントリにある特定の巨大アイテムの数量を減らします。非常に大きな値をサポートするため、消費数量は文字列で指定します。
ゲーム独自のロジックでプレイヤーが大きな数値のリソースを消費する場合に使います。たとえば、プレステージアップグレードに「メガゴールド 1,000,000,000」を使う場合や、累積ポイントを消費する場合です。
注意: 商品の購入（GS2-Showcase）やクエストの開始（GS2-Quest）の対価としてアイテムを消費する場合は、それらのシステムが自動的に処理するため、このAPIを呼ぶ必要はありません。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | 巨大アイテムモデル名
巨大アイテムモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| consumeCount | string | | ✓| | ~ 1024文字 | 巨大アイテムの消費数量
最大1024桁までの整数値文字列 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzBigItem](#ezbigitem) | 消費後の巨大アイテム|
#### Error
このAPIには特別な例外が定義されています。
GS2-SDK for Game Engine ではゲーム内でハンドリングが必要そうなエラーは一般的な例外から派生した特殊化した例外を用意することでハンドリングしやすくしています。
一般的なエラーの種類や、ハンドリング方法は [こちら]() のドキュメントを参考にしてください。
| 型 | 基底クラス | 説明 |
| --- | --- | --- |
| ConflictException | ConflictException | アイテムの操作処理が衝突しました。リトライが必要です |
| InsufficientException | BadRequestException | アイテムの所持数量が不足しています |
#### 実装例
**Unity (UniTask)**
```csharp
try {
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "inventory-0001"
).BigItem(
itemName: "item-0001"
);
var result = await domain.ConsumeBigItemAsync(
consumeCount: "1234567890123456789012345678901234567890"
);
var item = await result.ModelAsync();
} catch(Gs2.Gs2Inventory.Exception.ConflictException e) {
// Item manipulation process conflicted. Retry required.
} catch(Gs2.Gs2Inventory.Exception.InsufficientException e) {
// Insufficient quantity of items in your possession.
}
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "inventory-0001"
).BigItem(
itemName: "item-0001"
);
var future = domain.ConsumeBigItemFuture(
consumeCount: "1234567890123456789012345678901234567890"
);
yield return future;
if (future.Error != null)
{
if (future.Error is Gs2.Gs2Inventory.Exception.ConflictException)
{
// Item manipulation process conflicted. Retry required.
}
if (future.Error is Gs2.Gs2Inventory.Exception.InsufficientException)
{
// Insufficient quantity of items in your possession.
}
onError.Invoke(future.Error, null);
yield break;
}
var future2 = future.Result.ModelFuture();
yield return future2;
if (future2.Error != null)
{
onError.Invoke(future2.Error, null);
yield break;
}
var result = future2.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->BigInventory(
"inventory-0001" // inventoryName
)->BigItem(
"item-0001" // itemName
);
const auto Future = Domain->ConsumeBigItem(
"1234567890123456789012345678901234567890" // consumeCount
);
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
auto e = Future->GetTask().Error();
if (e->IsChildOf(Gs2::Inventory::Error::FConflictError::Class))
{
// Item manipulation process conflicted. Retry required.
}
if (e->IsChildOf(Gs2::Inventory::Error::FInsufficientError::Class))
{
// Insufficient quantity of items in your possession.
}
return false;
}
// obtain changed values / result values
const auto Future2 = Future->GetTask().Result()->Model();
Future2->StartSynchronousTask();
if (Future2->GetTask().IsError())
{
return Future2->GetTask().Error();
}
const auto Result = Future2->GetTask().Result();
```
---
### getBigItem
特定の巨大アイテムの所持数を取得する
プレイヤーが所持する特定の巨大アイテムの現在の数量を取得します。非常に大きな値をサポートするため、数量は文字列で返されます。
特定の大きな数値のリソースを確認するのに使います。たとえば、ゲームのメイン画面で「メガゴールド: 1,234,567,890」と表示したり、プレイヤープロフィールで「累計XP: 9,876,543,210」と表示するのに便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| itemName | string | | ✓| | ~ 128文字 | 巨大アイテムモデル名
このレコードに格納されているアイテムの種類を定義する巨大アイテムモデルの名前です。この巨大アイテムの所持品がどのアイテム定義に対応するかを識別するために使用されます。 |
| gameSession | GameSession | | ✓| | | GameSession |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| item | [EzBigItem](#ezbigitem) | 巨大アイテム|
| itemModel | [EzBigItemModel](#ezbigitemmodel) | 巨大アイテムモデル|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
).BigItem(
itemName: "item-0001"
);
var item = await domain.ModelAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
).BigItem(
itemName: "item-0001"
);
var future = domain.ModelFuture();
yield return future;
var item = future.Result;
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->BigInventory(
"item" // inventoryName
)->BigItem(
"item-0001" // itemName
);
const auto Future = Domain->Model();
Future->StartSynchronousTask();
if (Future->GetTask().IsError())
{
return false;
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
).BigItem(
itemName: "item-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
).BigItem(
itemName: "item-0001"
);
// イベントハンドリングを開始
var callbackId = domain.Subscribe(
value => {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
domain.Unsubscribe(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->BigInventory(
"item" // inventoryName
)->BigItem(
"item-0001" // itemName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->Subscribe(
[](TSharedPtr value) {
// 値が変化した時に呼び出される
// value には変更後の値が渡ってくる
}
);
// イベントハンドリングを停止
Domain->Unsubscribe(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---
### listBigItems
巨大インベントリ内のプレイヤーが所持するアイテム一覧を取得する
指定した巨大インベントリでプレイヤーが現在所持しているすべての巨大アイテムを取得します。
各アイテムの数量は非常に大きな数値をサポートするため文字列で格納されています（例: "1234567890123456789"）。
一度も入手したことのないアイテムは結果に含まれません。
プレイヤーの大きな数値のリソースを表示するのに使います。たとえば「メガゴールド: 1,234,567,890」「総ダメージ: 9,876,543,210,000」のような表示に便利です。
#### Request
| | 型 | 有効化条件 | 必須 | デフォルト | 値の制限 | 説明 |
| --- | --- | --- | --- | --- | --- | --- |
| namespaceName | string | | ✓| | ~ 128文字 | ネームスペース名
ネームスペース固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| inventoryName | string | | ✓| | ~ 128文字 | 巨大インベントリモデル名
巨大インベントリモデル固有の名前。英数字および -(ハイフン) _(アンダースコア) .(ピリオド)で指定します。 |
| gameSession | GameSession | | ✓| | | GameSession |
| pageToken | string | | | | ~ 1024文字 | データの取得を開始する位置を指定するトークン |
| limit | int | | | 30 | 1 ~ 1000 | データの取得件数 |
#### Result
| | 型 | 説明 |
| --- | --- | --- |
| items | [List<EzBigItem>](#ezbigitem) | 巨大アイテムのリスト|
| nextPageToken | string | リストの続きを取得するためのページトークン|
#### 実装例
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
);
var items = await domain.BigItemsAsync(
).ToListAsync();
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
);
var it = domain.BigItems(
);
List items = new List();
while (it.HasNext())
{
yield return it.Next();
if (it.Error != null)
{
onError.Invoke(it.Error, null);
break;
}
if (it.Current != null)
{
items.Add(it.Current);
}
else
{
break;
}
}
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->BigInventory(
"item" // inventoryName
);
const auto It = Domain->BigItems(
);
TArray Result;
for (auto Item : *It)
{
if (Item.IsError())
{
return false;
}
Result.Add(Item.Current());
}
```
##### 値の変更イベントハンドリング
**Unity (UniTask)**
```csharp
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeBigItems(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeBigItems(callbackId);
```
**Unity (Vanilla)**
```cs
var domain = gs2.Inventory.Namespace(
namespaceName: "namespace-0001"
).Me(
gameSession: GameSession
).BigInventory(
inventoryName: "item"
);
// イベントハンドリングを開始
var callbackId = domain.SubscribeBigItems(
() => {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
domain.UnsubscribeBigItems(callbackId);
```
**Unreal Engine 5**
```cpp
const auto Domain = Gs2->Inventory->Namespace(
"namespace-0001" // namespaceName
)->Me(
GameSession
)->BigInventory(
"item" // inventoryName
);
// イベントハンドリングを開始
const auto CallbackId = Domain->SubscribeBigItems(
[]() {
// リストの要素が変化した時に呼び出される
}
);
// イベントハンドリングを停止
Domain->UnsubscribeBigItems(CallbackId);
```
{{% alert title="Warning" color="warning" %}}このイベントはSDKがもつローカルキャッシュの値が変更された時に呼び出されます。
ローカルキャッシュは SDK が持つ API の実行、または GS2-Gateway の通知を有効にした GS2-Distributor 経由でのスタンプシートの実行、または GS2-Gateway の通知を有効にした GS2-JobQueue の実行によって変化したもののみが対象となります。
そのため、これらの方法以外で値が変更されてもコールバックは呼び出されません。
{{% /alert %}}
---