Fabric Wiki

User Tools

Site Tools

Trace:
tutorial:inventory

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revisionPrevious revision
Next revision		Previous revision
tutorial:inventory [2020/07/16 23:54] – update activate references to onUse user11681tutorial:inventory [2023/11/06 23:28] (current) – binaris00
Line 17: Line 17:
  */  */
 public interface ImplementedInventory extends Inventory { public interface ImplementedInventory extends Inventory {
 +
     /**     /**
-     * Gets the item list of this inventory.+     * Retrieves the item list of this inventory.
      * Must return the same instance every time it's called.      * Must return the same instance every time it's called.
      */      */
     DefaultedList<ItemStack> getItems();     DefaultedList<ItemStack> getItems();
-    // Creation+    
     /**     /**
      * Creates an inventory from the item list.      * Creates an inventory from the item list.
Line 29: Line 30:
         return () -> items;         return () -> items;
     }     }
 +    
     /**     /**
-     * Creates a new inventory with the size.+     * Creates a new inventory with the specified size.
      */      */
     static ImplementedInventory ofSize(int size) {     static ImplementedInventory ofSize(int size) {
         return of(DefaultedList.ofSize(size, ItemStack.EMPTY));         return of(DefaultedList.ofSize(size, ItemStack.EMPTY));
     }     }
-    // Inventory+    
     /**     /**
      * Returns the inventory size.      * Returns the inventory size.
      */      */
     @Override     @Override
-    default int getInvSize() {+    default int size() {
         return getItems().size();         return getItems().size();
     }     }
 +    
     /**     /**
-     * @return true if this inventory has only empty stacks, false otherwise+     * Checks if the inventory is empty. 
 +     * @return true if this inventory has only empty stacks, false otherwise.
      */      */
     @Override     @Override
-    default boolean isInvEmpty() { +    default boolean isEmpty() { 
-        for (int i = 0; i < getInvSize(); i++) { +        for (int i = 0; i < size(); i++) { 
-            ItemStack stack = getInvStack(i);+            ItemStack stack = getStack(i);
             if (!stack.isEmpty()) {             if (!stack.isEmpty()) {
                 return false;                 return false;
Line 56: Line 60:
         return true;         return true;
     }     }
 +    
     /**     /**
-     * Gets the item in the slot.+     * Retrieves the item in the slot.
      */      */
     @Override     @Override
-    default ItemStack getInvStack(int slot) {+    default ItemStack getStack(int slot) {
         return getItems().get(slot);         return getItems().get(slot);
     }     }
 +    
     /**     /**
-     * Takes a stack of the size from the slot. +     * Removes items from an inventory slot. 
-     * <p>(default implementation) If there are less items in the slot than what are requested, +     * @param slot  The slot to remove from. 
-     * takes all items in that slot.+     * @param count How many items to remove. If there are less items in the slot than what are requested, 
 +     *              takes all items in that slot.
      */      */
     @Override     @Override
-    default ItemStack takeInvStack(int slot, int count) {+    default ItemStack removeStack(int slot, int count) {
         ItemStack result = Inventories.splitStack(getItems(), slot, count);         ItemStack result = Inventories.splitStack(getItems(), slot, count);
         if (!result.isEmpty()) {         if (!result.isEmpty()) {
Line 76: Line 83:
         return result;         return result;
     }     }
 +    
     /**     /**
-     * Removes the current stack in the {@code slot} and returns it.+     * Removes all items from an inventory slot. 
 +     * @param slot The slot to remove from.
      */      */
     @Override     @Override
-    default ItemStack removeInvStack(int slot) {+    default ItemStack removeStack(int slot) {
         return Inventories.removeStack(getItems(), slot);         return Inventories.removeStack(getItems(), slot);
     }     }
 +    
     /**     /**
-     * Replaces the current stack in the {@code slot} with the provided stack. +     * Replaces the current stack in an inventory slot with the provided stack. 
-     * <p>If the stack is too big for this inventory ({@link Inventory#getInvMaxStackAmount()}), +     * @param slot  The inventory slot of which to replace the itemstack. 
-     * it gets resized to this inventory's maximum amount.+     * @param stack The replacing itemstack. If the stack is too big for 
 +     *              this inventory ({@link Inventory#getMaxCountPerStack()}), 
 +     *              it gets resized to this inventory's maximum amount.
      */      */
     @Override     @Override
-    default void setInvStack(int slot, ItemStack stack) {+    default void setStack(int slot, ItemStack stack) {
         getItems().set(slot, stack);         getItems().set(slot, stack);
-        if (stack.getCount() > getInvMaxStackAmount()) { +        if (stack.getCount() > stack.getMaxCount()) { 
-            stack.setCount(getInvMaxStackAmount());+            stack.setCount(stack.getMaxCount());
         }         }
     }     }
 +    
     /**     /**
-     * Clears {@linkplain #getItems() the item list}}.+     * Clears the inventory.
      */      */
     @Override     @Override
Line 102: Line 115:
         getItems().clear();         getItems().clear();
     }     }
 +    
 +    /**
 +     * Marks the state as dirty.
 +     * Must be called after changes in the inventory, so that the game can properly save
 +     * the inventory contents and notify neighboring blocks of inventory changes.
 +     */ 
     @Override     @Override
     default void markDirty() {     default void markDirty() {
         // Override if you want behavior.         // Override if you want behavior.
     }     }
 +    
 +    /**
 +     * @return true if the player can use the inventory, false otherwise.
 +     */ 
     @Override     @Override
-    default boolean canPlayerUseInv(PlayerEntity player) {+    default boolean canPlayerUse(PlayerEntity player) {
         return true;         return true;
     }     }
Line 135: Line 158:
     [...]     [...]
     @Override     @Override
-    public void fromTag(CompoundTag tag) { +    public void readNbt(NbtCompound nbt) { 
-        super.fromTag(tag); +        super.readNbt(nbt); 
-        Inventories.fromTag(tag,items);+        Inventories.readNbt(nbt, items);
     }     }
  
     @Override     @Override
-    public CompoundTag toTag(CompoundTag tag) { +    public NbtCompound writeNbt(NbtCompound nbt) { 
-        Inventories.toTag(tag,items); +        Inventories.writeNbt(nbt, items); 
-        return super.toTag(tag);+        return super.writeNbt(nbt);
     }     }
 } }
Line 158: Line 181:
     [...]     [...]
     @Override     @Override
-    public boolean onUse(BlockState blockState, World world, BlockPos blockPos, PlayerEntity player, Hand hand, BlockHitResult blockHitResult) { +    public ActionResult onUse(BlockState blockState, World world, BlockPos blockPos, PlayerEntity player, Hand hand, BlockHitResult blockHitResult) { 
-        if (world.isClient) return true;+        if (world.isClient) return ActionResult.SUCCESS;
         Inventory blockEntity = (Inventory) world.getBlockEntity(blockPos);         Inventory blockEntity = (Inventory) world.getBlockEntity(blockPos);
  
Line 165: Line 188:
         if (!player.getStackInHand(hand).isEmpty()) {         if (!player.getStackInHand(hand).isEmpty()) {
             // Check what is the first open slot and put an item from the player's hand there             // Check what is the first open slot and put an item from the player's hand there
-            if (blockEntity.getInvStack(0).isEmpty()) {+            if (blockEntity.getStack(0).isEmpty()) {
                 // Put the stack the player is holding into the inventory                 // Put the stack the player is holding into the inventory
-                blockEntity.setInvStack(0, player.getStackInHand(hand).copy());+                blockEntity.setStack(0, player.getStackInHand(hand).copy());
                 // Remove the stack from the player's hand                 // Remove the stack from the player's hand
                 player.getStackInHand(hand).setCount(0);                 player.getStackInHand(hand).setCount(0);
-            } else if (blockEntity.getInvStack(1).isEmpty()) { +            } else if (blockEntity.getStack(1).isEmpty()) { 
-                blockEntity.setInvStack(1, player.getStackInHand(hand).copy());+                blockEntity.setStack(1, player.getStackInHand(hand).copy());
                 player.getStackInHand(hand).setCount(0);                 player.getStackInHand(hand).setCount(0);
             } else {             } else {
                 // If the inventory is full we'll print it's contents                 // If the inventory is full we'll print it's contents
                 System.out.println("The first slot holds "                 System.out.println("The first slot holds "
-                        + blockEntity.getInvStack(0) + " and the second slot holds " + blockEntity.getInvStack(1));+                        + blockEntity.getStack(0) + " and the second slot holds " + blockEntity.getStack(1));
             }             }
         }          } 
-        return true;+        return ActionResult.SUCCESS;
     }     }
 } }
Line 191: Line 214:
     [...]     [...]
     @Override     @Override
-    public boolean onUse(BlockState blockState, World world, BlockPos blockPos, PlayerEntity player, Hand hand, BlockHitResult blockHitResult) {+    public ActionResult onUse(BlockState blockState, World world, BlockPos blockPos, PlayerEntity player, Hand hand, BlockHitResult blockHitResult) {
         ...         ...
         if (!player.getStackInHand(hand).isEmpty()) {         if (!player.getStackInHand(hand).isEmpty()) {
Line 199: Line 222:
  
              // Find the first slot that has an item and give it to the player              // Find the first slot that has an item and give it to the player
-            if (!blockEntity.getInvStack(1).isEmpty()) {+            if (!blockEntity.getStack(1).isEmpty()) {
                 // Give the player the stack in the inventory                 // Give the player the stack in the inventory
-                player.inventory.offerOrDrop(world, blockEntity.getInvStack(1));+                player.getInventory().offerOrDrop(blockEntity.getStack(1));
                 // Remove the stack from the inventory                 // Remove the stack from the inventory
-                blockEntity.removeInvStack(1); +                blockEntity.removeStack(1); 
-            } else if (!blockEntity.getInvStack(0).isEmpty()) { +            } else if (!blockEntity.getStack(0).isEmpty()) { 
-                player.inventory.offerOrDrop(world, blockEntity.getInvStack(0)); +                player.getInventory().offerOrDrop(blockEntity.getStack(0)); 
-                blockEntity.removeInvStack(0);+                blockEntity.removeStack(0);
             }             }
         }         }
                  
-        return true;+        return ActionResult.SUCCESS;
     }     }
 } }
Line 223: Line 246:
     [...]     [...]
     @Override     @Override
-    public int[] getInvAvailableSlots(Direction var1) {+    public int[] getInvAvailableSlots(Direction side) {
         // Just return an array of all slots         // Just return an array of all slots
         int[] result = new int[getItems().size()];         int[] result = new int[getItems().size()];
Line 234: Line 257:
  
     @Override     @Override
-    public boolean canInsertInvStack(int slot, ItemStack stack, Direction direction) {+    public boolean canInsert(int slot, ItemStack stack, Direction direction) {
         return direction != Direction.UP;         return direction != Direction.UP;
     }     }
  
     @Override     @Override
-    public boolean canExtractInvStack(int slot, ItemStack stack, Direction direction) {+    public boolean canExtract(int slot, ItemStack stack, Direction direction) {
         return true;         return true;
     }     }
tutorial/inventory.txt · Last modified: 2023/11/06 23:28 by binaris00