669 lines
23 KiB
Markdown
669 lines
23 KiB
Markdown
---
|
|
title: Conteneurs
|
|
type: docs
|
|
weight: 2
|
|
---
|
|
|
|
Les conteneurs gèrent des collections d'ItemStacks dans Hytale. Le système d'inventaire utilise `ItemContainer` comme abstraction de base avec `Inventory` comme conteneur multi-sections spécialisé du joueur.
|
|
|
|
## Structure de l'Inventaire
|
|
|
|
Les inventaires des joueurs sont composés de plusieurs sections `ItemContainer` :
|
|
|
|
```java
|
|
Inventory inv = player.getInventory();
|
|
|
|
// Obtenir les sections individuelles
|
|
ItemContainer storage = inv.getStorage(); // Stockage principal (36 slots par défaut)
|
|
ItemContainer hotbar = inv.getHotbar(); // Hotbar (9 slots par défaut)
|
|
ItemContainer armor = inv.getArmor(); // Emplacements d'armure
|
|
ItemContainer utility = inv.getUtility(); // Objets utilitaires (4 slots par défaut)
|
|
ItemContainer backpack = inv.getBackpack(); // Sac à dos (extensible)
|
|
|
|
// Conteneurs combinés pour opérations multi-sections
|
|
CombinedItemContainer hotbarFirst = inv.getCombinedHotbarFirst();
|
|
CombinedItemContainer storageFirst = inv.getCombinedStorageFirst();
|
|
```
|
|
|
|
### IDs de Section
|
|
|
|
Chaque section a un ID constant pour les opérations :
|
|
|
|
| Section | ID | Constante |
|
|
|---------|----|----|
|
|
| Hotbar | -1 | `Inventory.HOTBAR_SECTION_ID` |
|
|
| Stockage | -2 | `Inventory.STORAGE_SECTION_ID` |
|
|
| Armure | -3 | `Inventory.ARMOR_SECTION_ID` |
|
|
| Utilitaire | -5 | `Inventory.UTILITY_SECTION_ID` |
|
|
| Outils | -8 | `Inventory.TOOLS_SECTION_ID` (déprécié) |
|
|
| Sac à dos | -9 | `Inventory.BACKPACK_SECTION_ID` |
|
|
|
|
## Bases d'ItemContainer
|
|
|
|
### Lire les Objets
|
|
|
|
```java
|
|
ItemContainer container = inv.getStorage();
|
|
|
|
// Obtenir la capacité (PAS getSize!)
|
|
short capacity = container.getCapacity();
|
|
|
|
// Obtenir l'objet au slot (slot est de type SHORT)
|
|
ItemStack item = container.getItemStack((short) 0);
|
|
|
|
// Vérifier si vide
|
|
boolean empty = container.isEmpty();
|
|
|
|
// Accès sécurisé aux objets
|
|
ItemStack stack = container.getItemStack((short) slot);
|
|
if (!ItemStack.isEmpty(stack)) {
|
|
String itemId = stack.getItemId();
|
|
int quantity = stack.getQuantity();
|
|
}
|
|
```
|
|
|
|
### Définir des Objets
|
|
|
|
```java
|
|
ItemContainer container = inv.getHotbar();
|
|
|
|
// Définir l'objet au slot - retourne une Transaction
|
|
ItemStackSlotTransaction transaction = container.setItemStackForSlot(
|
|
(short) 0,
|
|
new ItemStack("iron_sword", 1)
|
|
);
|
|
|
|
// Vérifier si l'opération a réussi
|
|
if (transaction.succeeded()) {
|
|
// L'objet a été défini avec succès
|
|
}
|
|
|
|
// Vider un slot
|
|
container.setItemStackForSlot((short) 0, null);
|
|
```
|
|
|
|
### Ajouter des Objets
|
|
|
|
```java
|
|
ItemContainer container = inv.getStorage();
|
|
ItemStack toAdd = new ItemStack("wood_plank", 64);
|
|
|
|
// Ajouter au premier slot disponible (empile avec les objets existants d'abord)
|
|
ItemStackTransaction transaction = container.addItemStack(toAdd);
|
|
|
|
// Vérifier les objets restants qui n'ont pas pu rentrer
|
|
ItemStack remainder = transaction.getRemainder();
|
|
if (!ItemStack.isEmpty(remainder)) {
|
|
// Certains objets n'ont pas pu rentrer
|
|
int leftover = remainder.getQuantity();
|
|
}
|
|
|
|
// Ajouter à un slot spécifique
|
|
ItemStackSlotTransaction slotTransaction = container.addItemStackToSlot(
|
|
(short) 5,
|
|
toAdd
|
|
);
|
|
|
|
// Vérifier si le conteneur peut accueillir les objets avant d'ajouter
|
|
if (container.canAddItemStack(toAdd)) {
|
|
container.addItemStack(toAdd);
|
|
}
|
|
```
|
|
|
|
### Retirer des Objets
|
|
|
|
```java
|
|
// Retirer d'un slot spécifique
|
|
SlotTransaction transaction = container.removeItemStackFromSlot((short) 0);
|
|
|
|
// Retirer une quantité spécifique du slot
|
|
ItemStackSlotTransaction removeTransaction = container.removeItemStackFromSlot(
|
|
(short) 0,
|
|
10 // quantité à retirer
|
|
);
|
|
|
|
// Retirer un type d'objet spécifique de n'importe où dans le conteneur
|
|
ItemStack toRemove = new ItemStack("iron_ore", 5);
|
|
ItemStackTransaction itemTransaction = container.removeItemStack(toRemove);
|
|
|
|
// Vérifier si les objets peuvent être retirés avant de retirer
|
|
if (container.canRemoveItemStack(toRemove)) {
|
|
container.removeItemStack(toRemove);
|
|
}
|
|
```
|
|
|
|
## Slots Actifs
|
|
|
|
Les joueurs ont des slots actifs pour la hotbar et les objets utilitaires :
|
|
|
|
```java
|
|
Inventory inv = player.getInventory();
|
|
|
|
// Obtenir le slot actif de la hotbar (0-8)
|
|
byte activeHotbar = inv.getActiveHotbarSlot();
|
|
|
|
// Définir le slot actif de la hotbar
|
|
inv.setActiveHotbarSlot((byte) 3);
|
|
|
|
// Obtenir l'objet actuellement en main
|
|
ItemStack handItem = inv.getItemInHand();
|
|
|
|
// Obtenir/définir le slot utilitaire actif
|
|
byte activeUtility = inv.getActiveUtilitySlot();
|
|
inv.setActiveUtilitySlot((byte) 1);
|
|
|
|
// Obtenir l'objet utilitaire
|
|
ItemStack utilityItem = inv.getUtilityItem();
|
|
```
|
|
|
|
## Déplacer des Objets
|
|
|
|
### Entre les Slots
|
|
|
|
```java
|
|
Inventory inv = player.getInventory();
|
|
ItemContainer storage = inv.getStorage();
|
|
ItemContainer hotbar = inv.getHotbar();
|
|
|
|
// Déplacer un objet d'un slot à un autre dans le même conteneur
|
|
MoveTransaction<SlotTransaction> transaction = storage.moveItemStackFromSlotToSlot(
|
|
(short) 0, // depuis slot
|
|
64, // quantité
|
|
storage, // vers conteneur
|
|
(short) 5 // vers slot
|
|
);
|
|
|
|
// Déplacer entre différents conteneurs
|
|
storage.moveItemStackFromSlotToSlot(
|
|
(short) 0,
|
|
32,
|
|
hotbar,
|
|
(short) 0
|
|
);
|
|
|
|
// Utiliser moveItem de l'Inventory pour les déplacements par section
|
|
inv.moveItem(
|
|
Inventory.STORAGE_SECTION_ID, // depuis section
|
|
5, // depuis slot
|
|
10, // quantité
|
|
Inventory.HOTBAR_SECTION_ID, // vers section
|
|
0 // vers slot
|
|
);
|
|
```
|
|
|
|
### Déplacement Intelligent
|
|
|
|
```java
|
|
// Le déplacement intelligent considère le type d'objet pour un placement optimal
|
|
inv.smartMoveItem(
|
|
Inventory.STORAGE_SECTION_ID,
|
|
0, // slot
|
|
64, // quantité
|
|
SmartMoveType.EquipOrMergeStack // tente d'équiper l'armure ou fusionner les piles
|
|
);
|
|
```
|
|
|
|
## Itérer les Conteneurs
|
|
|
|
```java
|
|
ItemContainer container = inv.getStorage();
|
|
|
|
// Itérer tous les slots non vides
|
|
container.forEach((slot, itemStack) -> {
|
|
getLogger().at(Level.INFO).log("Slot " + slot + ": " +
|
|
itemStack.getItemId() + " x" + itemStack.getQuantity());
|
|
});
|
|
|
|
// Compter les objets correspondant à une condition
|
|
int swordCount = container.countItemStacks(
|
|
stack -> stack.getItemId().contains("sword")
|
|
);
|
|
|
|
// Vérifier si le conteneur a des objets empilables
|
|
ItemStack testStack = new ItemStack("stone", 1);
|
|
boolean hasStackable = container.containsItemStacksStackableWith(testStack);
|
|
```
|
|
|
|
## Vérifier le Contenu
|
|
|
|
```java
|
|
ItemContainer container = inv.getStorage();
|
|
|
|
// Vérifier si l'inventaire contient un type et quantité d'objet spécifiques
|
|
public boolean hasItems(ItemContainer container, String itemId, int amount) {
|
|
int count = container.countItemStacks(
|
|
stack -> stack.getItemId().equals(itemId)
|
|
);
|
|
return count >= amount;
|
|
}
|
|
|
|
// Trouver le premier slot avec un objet spécifique
|
|
public short findSlotWithItem(ItemContainer container, String itemId) {
|
|
for (short i = 0; i < container.getCapacity(); i++) {
|
|
ItemStack stack = container.getItemStack(i);
|
|
if (!ItemStack.isEmpty(stack) && stack.getItemId().equals(itemId)) {
|
|
return i;
|
|
}
|
|
}
|
|
return -1; // Non trouvé
|
|
}
|
|
|
|
// Compter les slots vides
|
|
public int countEmptySlots(ItemContainer container) {
|
|
int empty = 0;
|
|
for (short i = 0; i < container.getCapacity(); i++) {
|
|
if (ItemStack.isEmpty(container.getItemStack(i))) {
|
|
empty++;
|
|
}
|
|
}
|
|
return empty;
|
|
}
|
|
```
|
|
|
|
## Vider les Conteneurs
|
|
|
|
```java
|
|
ItemContainer container = inv.getStorage();
|
|
|
|
// Vider tout le conteneur
|
|
ClearTransaction transaction = container.clear();
|
|
|
|
// Lâcher tous les objets (retourne la liste des objets lâchés)
|
|
List<ItemStack> droppedItems = container.dropAllItemStacks();
|
|
|
|
// Retirer tous les objets (retourne la liste)
|
|
List<ItemStack> removedItems = container.removeAllItemStacks();
|
|
|
|
// Vider tout l'inventaire du joueur
|
|
inv.clear();
|
|
|
|
// Lâcher tout de l'inventaire du joueur
|
|
List<ItemStack> allDropped = inv.dropAllItemStacks();
|
|
```
|
|
|
|
## Tri
|
|
|
|
Valeurs `SortType` disponibles : `NAME`, `TYPE`, `RARITY`
|
|
|
|
```java
|
|
ItemContainer container = inv.getStorage();
|
|
|
|
// Trier les objets
|
|
container.sortItems(SortType.NAME);
|
|
|
|
// Trier via Inventory (sauvegarde aussi la préférence de tri)
|
|
inv.sortStorage(SortType.NAME);
|
|
inv.setSortType(SortType.RARITY); // Ou TYPE
|
|
```
|
|
|
|
## Événements de Conteneur
|
|
|
|
```java
|
|
// S'enregistrer pour les événements de changement de conteneur
|
|
container.registerChangeEvent(event -> {
|
|
ItemContainer changedContainer = event.container();
|
|
Transaction transaction = event.transaction();
|
|
|
|
getLogger().at(Level.INFO).log("Conteneur modifié !");
|
|
});
|
|
|
|
// Avec priorité
|
|
container.registerChangeEvent(EventPriority.EARLY, event -> {
|
|
// Gérer tôt
|
|
});
|
|
```
|
|
|
|
## Système de Transactions
|
|
|
|
Toutes les opérations de modification retournent des objets Transaction :
|
|
|
|
```java
|
|
// Les transactions suivent le succès et les changements
|
|
ItemStackTransaction transaction = container.addItemStack(itemStack);
|
|
|
|
if (transaction.succeeded()) {
|
|
ItemStack remainder = transaction.getRemainder();
|
|
// ...
|
|
}
|
|
|
|
// Les transactions de slot incluent les infos du slot
|
|
ItemStackSlotTransaction slotTransaction = container.setItemStackForSlot(
|
|
(short) 0,
|
|
itemStack
|
|
);
|
|
|
|
if (slotTransaction.succeeded()) {
|
|
short slot = slotTransaction.getSlot();
|
|
ItemStack before = slotTransaction.getSlotBefore();
|
|
ItemStack after = slotTransaction.getSlotAfter();
|
|
}
|
|
```
|
|
|
|
## Paramètres d'Opération
|
|
|
|
La plupart des opérations de conteneur supportent des paramètres optionnels :
|
|
|
|
```java
|
|
// Valeurs par défaut
|
|
DEFAULT_ADD_ALL_OR_NOTHING = false; // Ajouts partiels autorisés
|
|
DEFAULT_REMOVE_ALL_OR_NOTHING = true; // Uniquement retraits complets
|
|
DEFAULT_FULL_STACKS = false; // Peut diviser les piles
|
|
DEFAULT_EXACT_AMOUNT = true; // Quantités exactes uniquement
|
|
DEFAULT_FILTER = true; // Applique les filtres de slot
|
|
|
|
// Ajouter avec paramètres
|
|
container.addItemStack(itemStack, allOrNothing, fullStacks, filter);
|
|
|
|
// allOrNothing: si true, échoue entièrement si tous les objets ne rentrent pas
|
|
// fullStacks: si true, remplit uniquement les slots vides (pas d'empilement)
|
|
// filter: si true, respecte les filtres de slot
|
|
```
|
|
|
|
## Retrait par Matériau et Ressource
|
|
|
|
Les conteneurs supportent le retrait d'objets par type de matériau ou de ressource (utilisé pour le craft) :
|
|
|
|
{{< callout type="info" >}}
|
|
**Constructeur MaterialQuantity :** `MaterialQuantity(itemId, resourceTypeId, tag, quantity, metadata)`
|
|
|
|
Au moins un parmi `itemId`, `resourceTypeId`, ou `tag` doit être non-null.
|
|
{{< /callout >}}
|
|
|
|
```java
|
|
// Retirer par matériau en utilisant itemId
|
|
MaterialQuantity materialByItem = new MaterialQuantity("iron_ingot", null, null, 5, null);
|
|
if (container.canRemoveMaterial(materialByItem)) {
|
|
MaterialTransaction transaction = container.removeMaterial(materialByItem);
|
|
}
|
|
|
|
// Retirer par matériau en utilisant resourceTypeId
|
|
MaterialQuantity materialByResource = new MaterialQuantity(null, "iron", null, 5, null);
|
|
if (container.canRemoveMaterial(materialByResource)) {
|
|
MaterialTransaction transaction = container.removeMaterial(materialByResource);
|
|
}
|
|
|
|
// Retirer par type de ressource (constructeur plus simple)
|
|
ResourceQuantity resource = new ResourceQuantity("wood", 10);
|
|
if (container.canRemoveResource(resource)) {
|
|
ResourceTransaction transaction = container.removeResource(resource);
|
|
}
|
|
|
|
// Retirer par index de tag
|
|
if (container.canRemoveTag(tagIndex, quantity)) {
|
|
TagTransaction transaction = container.removeTag(tagIndex, quantity);
|
|
}
|
|
|
|
// Retrait en masse
|
|
List<MaterialQuantity> materials = List.of(
|
|
new MaterialQuantity("iron_ingot", null, null, 2, null),
|
|
new MaterialQuantity(null, null, "Wood", 5, null) // Avec tag
|
|
);
|
|
if (container.canRemoveMaterials(materials)) {
|
|
container.removeMaterials(materials);
|
|
}
|
|
```
|
|
|
|
## Opérations en Masse
|
|
|
|
Ajouter ou retirer plusieurs objets à la fois :
|
|
|
|
```java
|
|
// Ajouter plusieurs objets
|
|
List<ItemStack> items = List.of(
|
|
new ItemStack("iron_ore", 10),
|
|
new ItemStack("gold_ore", 5)
|
|
);
|
|
|
|
if (container.canAddItemStacks(items)) {
|
|
ListTransaction<ItemStackTransaction> transaction = container.addItemStacks(items);
|
|
}
|
|
|
|
// Retirer plusieurs objets
|
|
if (container.canRemoveItemStacks(items)) {
|
|
container.removeItemStacks(items);
|
|
}
|
|
|
|
// Ajouter les objets dans l'ordre (préserve les positions de slot)
|
|
container.addItemStacksOrdered(items);
|
|
container.addItemStacksOrdered((short) 5, items); // À partir du slot 5
|
|
```
|
|
|
|
## Opérations de Déplacement Avancées
|
|
|
|
```java
|
|
// Déplacer tous les objets vers un autre conteneur
|
|
ListTransaction<MoveTransaction<ItemStackTransaction>> result =
|
|
storage.moveAllItemStacksTo(hotbar, backpack);
|
|
|
|
// Déplacer tous les objets correspondant à une condition
|
|
storage.moveAllItemStacksTo(
|
|
item -> item.getItemId().contains("ore"),
|
|
hotbar
|
|
);
|
|
|
|
// Quick stack : déplace uniquement les objets qui peuvent s'empiler avec des objets existants
|
|
storage.quickStackTo(hotbar);
|
|
|
|
// Combiner les petites piles dans un slot
|
|
container.combineItemStacksIntoSlot(targetContainer, (short) 0);
|
|
|
|
// Échanger des objets entre conteneurs
|
|
storage.swapItems(
|
|
(short) 0, // position source
|
|
hotbar, // conteneur cible
|
|
(short) 0, // position destination
|
|
(short) 5 // nombre de slots à échanger
|
|
);
|
|
```
|
|
|
|
## Opérations de Remplacement
|
|
|
|
```java
|
|
// Remplacer l'objet dans le slot s'il correspond à l'attendu
|
|
ItemStackSlotTransaction transaction = container.replaceItemStackInSlot(
|
|
(short) 0,
|
|
expectedItem, // doit correspondre à l'objet actuel pour continuer
|
|
newItem
|
|
);
|
|
|
|
// Remplacer tous les objets avec une fonction
|
|
container.replaceAll((slot, existing) -> {
|
|
if (existing.getItemId().equals("old_item")) {
|
|
return new ItemStack("new_item", existing.getQuantity());
|
|
}
|
|
return existing;
|
|
});
|
|
```
|
|
|
|
## Filtres de Slot
|
|
|
|
Contrôler quels objets peuvent aller dans quels slots :
|
|
|
|
```java
|
|
// Définir un filtre global pour le conteneur
|
|
container.setGlobalFilter(FilterType.WHITELIST);
|
|
|
|
// Définir un filtre pour un slot spécifique
|
|
container.setSlotFilter(
|
|
FilterActionType.ADD, // Filtre sur les opérations d'ajout
|
|
(short) 0, // Slot
|
|
slotFilter // Implémentation du filtre
|
|
);
|
|
```
|
|
|
|
## Bonnes Pratiques
|
|
|
|
{{< callout type="info" >}}
|
|
**Conseils pour les Conteneurs :**
|
|
- Les indices de slot sont `short`, pas `int` - castez correctement
|
|
- Vérifiez toujours `ItemStack.isEmpty(stack)` - gère null et vide
|
|
- Utilisez `getQuantity()` pas `getCount()`
|
|
- Vérifiez le succès de la transaction avec `succeeded()`
|
|
- Utilisez les conteneurs combinés pour les opérations multi-sections
|
|
- Les changements d'inventaire du joueur déclenchent `LivingEntityInventoryChangeEvent`
|
|
{{< /callout >}}
|
|
|
|
```java
|
|
// Pattern sécurisé pour travailler avec les conteneurs
|
|
public void safeAddItem(ItemContainer container, ItemStack item) {
|
|
if (ItemStack.isEmpty(item)) {
|
|
return;
|
|
}
|
|
|
|
if (!container.canAddItemStack(item)) {
|
|
// Gérer le conteneur plein
|
|
return;
|
|
}
|
|
|
|
ItemStackTransaction transaction = container.addItemStack(item);
|
|
if (!transaction.succeeded()) {
|
|
// Gérer l'échec
|
|
}
|
|
}
|
|
```
|
|
|
|
## Référence API ItemContainer
|
|
|
|
### Méthodes Principales
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `getCapacity()` | `short` | Nombre total de slots |
|
|
| `getItemStack(short)` | `ItemStack?` | Obtenir l'objet au slot |
|
|
| `isEmpty()` | `boolean` | True si aucun objet |
|
|
| `clone()` | `ItemContainer` | Cloner le conteneur |
|
|
| `clear()` | `ClearTransaction` | Retirer tous les objets |
|
|
|
|
### Opérations d'Ajout
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `canAddItemStack(ItemStack)` | `boolean` | Vérifier si peut ajouter |
|
|
| `canAddItemStack(ItemStack, fullStacks, filter)` | `boolean` | Vérifier avec options |
|
|
| `addItemStack(ItemStack)` | `ItemStackTransaction` | Ajouter au premier disponible |
|
|
| `addItemStack(ItemStack, allOrNothing, fullStacks, filter)` | `ItemStackTransaction` | Ajouter avec options |
|
|
| `canAddItemStackToSlot(short, ItemStack, allOrNothing, filter)` | `boolean` | Vérifier si peut ajouter au slot |
|
|
| `addItemStackToSlot(short, ItemStack)` | `ItemStackSlotTransaction` | Ajouter à un slot spécifique |
|
|
| `addItemStackToSlot(short, ItemStack, allOrNothing, filter)` | `ItemStackSlotTransaction` | Ajouter au slot avec options |
|
|
| `canAddItemStacks(List<ItemStack>)` | `boolean` | Vérifier si peut ajouter plusieurs |
|
|
| `addItemStacks(List<ItemStack>)` | `ListTransaction` | Ajouter plusieurs objets |
|
|
| `addItemStacksOrdered(List<ItemStack>)` | `ListTransaction` | Ajouter dans l'ordre |
|
|
| `addItemStacksOrdered(short offset, List<ItemStack>)` | `ListTransaction` | Ajouter dans l'ordre depuis offset |
|
|
|
|
### Opérations de Définition
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `setItemStackForSlot(short, ItemStack)` | `ItemStackSlotTransaction` | Définir l'objet au slot |
|
|
| `setItemStackForSlot(short, ItemStack, filter)` | `ItemStackSlotTransaction` | Définir avec option filtre |
|
|
| `replaceItemStackInSlot(short, ItemStack attendu, ItemStack nouveau)` | `ItemStackSlotTransaction` | Remplacer si correspondance |
|
|
| `replaceAll(SlotReplacementFunction)` | `ListTransaction` | Remplacer tous les objets |
|
|
|
|
### Opérations de Retrait
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `removeItemStackFromSlot(short)` | `SlotTransaction` | Retirer tout le slot |
|
|
| `removeItemStackFromSlot(short, filter)` | `SlotTransaction` | Retirer avec filtre |
|
|
| `removeItemStackFromSlot(short, quantity)` | `ItemStackSlotTransaction` | Retirer une quantité |
|
|
| `removeItemStackFromSlot(short, ItemStack, quantity)` | `ItemStackSlotTransaction` | Retirer objet correspondant |
|
|
| `canRemoveItemStack(ItemStack)` | `boolean` | Vérifier si peut retirer |
|
|
| `removeItemStack(ItemStack)` | `ItemStackTransaction` | Retirer type d'objet |
|
|
| `canRemoveItemStacks(List<ItemStack>)` | `boolean` | Vérifier si peut retirer plusieurs |
|
|
| `removeItemStacks(List<ItemStack>)` | `ListTransaction` | Retirer plusieurs objets |
|
|
| `removeAllItemStacks()` | `List<ItemStack>` | Retirer et retourner tous |
|
|
| `dropAllItemStacks()` | `List<ItemStack>` | Lâcher tous (respecte cantDrop) |
|
|
| `dropAllItemStacks(filter)` | `List<ItemStack>` | Lâcher avec option filtre |
|
|
|
|
### Retrait Matériau/Ressource/Tag
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `canRemoveMaterial(MaterialQuantity)` | `boolean` | Vérifier retrait matériau |
|
|
| `removeMaterial(MaterialQuantity)` | `MaterialTransaction` | Retirer par matériau |
|
|
| `removeMaterialFromSlot(short, MaterialQuantity)` | `MaterialSlotTransaction` | Retirer matériau du slot |
|
|
| `canRemoveMaterials(List<MaterialQuantity>)` | `boolean` | Vérifier plusieurs matériaux |
|
|
| `removeMaterials(List<MaterialQuantity>)` | `ListTransaction` | Retirer plusieurs matériaux |
|
|
| `canRemoveResource(ResourceQuantity)` | `boolean` | Vérifier retrait ressource |
|
|
| `removeResource(ResourceQuantity)` | `ResourceTransaction` | Retirer par ressource |
|
|
| `removeResourceFromSlot(short, ResourceQuantity)` | `ResourceSlotTransaction` | Retirer ressource du slot |
|
|
| `canRemoveResources(List<ResourceQuantity>)` | `boolean` | Vérifier plusieurs ressources |
|
|
| `removeResources(List<ResourceQuantity>)` | `ListTransaction` | Retirer plusieurs ressources |
|
|
| `canRemoveTag(tagIndex, quantity)` | `boolean` | Vérifier retrait tag |
|
|
| `removeTag(tagIndex, quantity)` | `TagTransaction` | Retirer par tag |
|
|
| `removeTagFromSlot(short, tagIndex, quantity)` | `TagSlotTransaction` | Retirer tag du slot |
|
|
|
|
### Opérations de Déplacement
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `moveItemStackFromSlot(short, ItemContainer)` | `MoveTransaction` | Déplacer slot vers conteneur |
|
|
| `moveItemStackFromSlot(short, quantity, ItemContainer)` | `MoveTransaction` | Déplacer quantité |
|
|
| `moveItemStackFromSlot(short, ItemContainer...)` | `ListTransaction` | Déplacer vers plusieurs conteneurs |
|
|
| `moveItemStackFromSlotToSlot(short, quantity, ItemContainer, short)` | `MoveTransaction` | Déplacer vers slot spécifique |
|
|
| `moveAllItemStacksTo(ItemContainer...)` | `ListTransaction` | Déplacer tous les objets |
|
|
| `moveAllItemStacksTo(Predicate, ItemContainer...)` | `ListTransaction` | Déplacer objets correspondants |
|
|
| `quickStackTo(ItemContainer...)` | `ListTransaction` | Déplacer uniquement empilables |
|
|
| `combineItemStacksIntoSlot(ItemContainer, short)` | `ListTransaction` | Combiner piles dans slot |
|
|
| `swapItems(short srcPos, ItemContainer, short destPos, short length)` | `ListTransaction` | Échanger plages d'objets |
|
|
|
|
### Méthodes Utilitaires
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `forEach(ShortObjectConsumer)` | `void` | Itérer slots non vides |
|
|
| `forEachWithMeta(consumer, meta)` | `void` | Itérer avec métadonnées |
|
|
| `countItemStacks(Predicate)` | `int` | Compter objets correspondants (quantité totale) |
|
|
| `containsItemStacksStackableWith(ItemStack)` | `boolean` | Vérifier objets empilables |
|
|
| `sortItems(SortType)` | `ListTransaction` | Trier conteneur |
|
|
| `registerChangeEvent(Consumer)` | `EventRegistration` | Écouter les changements |
|
|
| `registerChangeEvent(EventPriority, Consumer)` | `EventRegistration` | Écouter avec priorité |
|
|
| `setGlobalFilter(FilterType)` | `void` | Définir filtre conteneur |
|
|
| `setSlotFilter(FilterActionType, short, SlotFilter)` | `void` | Définir filtre slot |
|
|
| `containsContainer(ItemContainer)` | `boolean` | Vérifier si contient conteneur |
|
|
|
|
### Méthodes Statiques
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `copy(from, to, remainder)` | `T` | Copier objets entre conteneurs |
|
|
| `ensureContainerCapacity(container, capacity, supplier, remainder)` | `T` | S'assurer de la capacité |
|
|
| `getNewContainer(capacity, supplier)` | `ItemContainer` | Créer ou obtenir vide |
|
|
| `getMatchingResourceType(Item, resourceId)` | `ItemResourceType?` | Trouver type ressource pour objet |
|
|
| `validateQuantity(int)` | `void` | Lance exception si < 0 |
|
|
| `validateSlotIndex(short, capacity)` | `void` | Lance exception si hors limites |
|
|
|
|
### Constantes Statiques
|
|
|
|
| Champ | Type | Description |
|
|
|-------|------|-------------|
|
|
| `CODEC` | `CodecMapCodec<ItemContainer>` | Codec de sérialisation |
|
|
| `DEFAULT_ADD_ALL_OR_NOTHING` | `boolean` | false |
|
|
| `DEFAULT_REMOVE_ALL_OR_NOTHING` | `boolean` | true |
|
|
| `DEFAULT_FULL_STACKS` | `boolean` | false |
|
|
| `DEFAULT_EXACT_AMOUNT` | `boolean` | true |
|
|
| `DEFAULT_FILTER` | `boolean` | true |
|
|
|
|
### Classes Imbriquées
|
|
|
|
| Classe | Description |
|
|
|-------|-------------|
|
|
| `ItemContainerChangeEvent` | Record événement avec `container()` et `transaction()` |
|
|
|
|
## Référence API Inventory
|
|
|
|
| Méthode | Retour | Description |
|
|
|--------|---------|-------------|
|
|
| `getStorage()` | `ItemContainer` | Section de stockage principal |
|
|
| `getHotbar()` | `ItemContainer` | Section hotbar |
|
|
| `getArmor()` | `ItemContainer` | Section armure |
|
|
| `getUtility()` | `ItemContainer` | Section utilitaire |
|
|
| `getBackpack()` | `ItemContainer` | Section sac à dos |
|
|
| `getSectionById(int)` | `ItemContainer?` | Obtenir section par ID |
|
|
| `getItemInHand()` | `ItemStack?` | Objet actuellement tenu |
|
|
| `getActiveHotbarSlot()` | `byte` | Slot actif de la hotbar |
|
|
| `setActiveHotbarSlot(byte)` | `void` | Définir hotbar active |
|
|
| `getCombinedHotbarFirst()` | `CombinedItemContainer` | Hotbar+Stockage combinés |
|
|
| `moveItem(...)` | `void` | Déplacer entre sections |
|
|
| `clear()` | `void` | Vider toutes les sections |
|