Merge branch 'master' into acquirable

src/main/java/net/minestom/server/inventory/TransactionType.java

@@ -32,7 +32,8 @@ public interface TransactionType {
             }
             if (stackingRule.canBeStacked(itemStack, inventoryItem)) {
                 final int itemAmount = stackingRule.getAmount(inventoryItem);
-                if (itemAmount == stackingRule.getMaxSize())
+                final int maxSize = stackingRule.getMaxSize(inventoryItem);
+                if (itemAmount == maxSize)
                     continue;
 
                 if (!slotPredicate.test(i, inventoryItem)) {
@@ -44,8 +45,8 @@ public interface TransactionType {
                 final int totalAmount = itemStackAmount + itemAmount;
                 if (!stackingRule.canApply(itemStack, totalAmount)) {
                     // Slot cannot accept the whole item, reduce amount to 'itemStack'
-                    itemChangesMap.put(i, stackingRule.apply(inventoryItem, stackingRule.getMaxSize()));
+                    itemChangesMap.put(i, stackingRule.apply(inventoryItem, maxSize));
-                    itemStack = stackingRule.apply(itemStack, totalAmount - stackingRule.getMaxSize());
+                    itemStack = stackingRule.apply(itemStack, totalAmount - maxSize);
                 } else {
                     // Slot can accept the whole item
                     itemChangesMap.put(i, stackingRule.apply(inventoryItem, totalAmount));
@@ -97,10 +98,12 @@ public interface TransactionType {
                 final int itemAmount = stackingRule.getAmount(inventoryItem);
                 final int itemStackAmount = stackingRule.getAmount(itemStack);
                 if (itemStackAmount < itemAmount) {
+                    System.out.println(1);
                     itemChangesMap.put(i, stackingRule.apply(inventoryItem, itemAmount - itemStackAmount));
                     itemStack = stackingRule.apply(itemStack, 0);
                     break;
                 }
+                System.out.println(2);
                 itemChangesMap.put(i, stackingRule.apply(inventoryItem, 0));
                 itemStack = stackingRule.apply(itemStack, itemStackAmount - itemAmount);
                 if (stackingRule.getAmount(itemStack) == 0) {

src/main/java/net/minestom/server/inventory/click/InventoryClickProcessor.java

@@ -57,10 +57,11 @@ public class InventoryClickProcessor {
 
         if (cursorRule.canBeStacked(cursor, clicked)) {
             final int totalAmount = cursorRule.getAmount(cursor) + clickedRule.getAmount(clicked);
+            final int maxSize = cursorRule.getMaxSize(cursor);
 
             if (!clickedRule.canApply(clicked, totalAmount)) {
-                resultCursor = cursorRule.apply(cursor, totalAmount - cursorRule.getMaxSize());
+                resultCursor = cursorRule.apply(cursor, totalAmount - maxSize);
-                resultClicked = clickedRule.apply(clicked, clickedRule.getMaxSize());
+                resultClicked = clickedRule.apply(clicked, maxSize);
             } else {
                 resultCursor = cursorRule.apply(cursor, 0);
                 resultClicked = clickedRule.apply(clicked, totalAmount);
@@ -256,7 +257,7 @@ public class InventoryClickProcessor {
                         break;
                     StackingRule slotItemRule = slotItem.getStackingRule();
 
-                    final int maxSize = stackingRule.getMaxSize();
+                    final int maxSize = stackingRule.getMaxSize(cursor);
                     if (stackingRule.canBeStacked(cursor, slotItem)) {
                         final int amount = slotItemRule.getAmount(slotItem);
                         if (stackingRule.canApply(slotItem, amount + slotSize)) {
@@ -351,7 +352,13 @@ public class InventoryClickProcessor {
 
         final StackingRule cursorRule = cursor.getStackingRule();
         final int amount = cursorRule.getAmount(cursor);
-        final int remainingAmount = cursorRule.getMaxSize() - amount;
+        final int maxSize = cursorRule.getMaxSize(cursor);
+        final int remainingAmount = maxSize - amount;
+
+        if (remainingAmount == 0) {
+            // Item is already full
+            return clickResult;
+        }
 
         ItemStack remain = cursorRule.apply(cursor, remainingAmount);
 
@@ -386,9 +393,15 @@ public class InventoryClickProcessor {
             remain = func.apply(playerInventory, remain);
         }
 
-        final int tookAmount = remainingAmount - cursorRule.getAmount(remain);
+        ItemStack resultCursor;
+        if (remain.isAir()) {
+            // Item has been filled
+            resultCursor = cursorRule.apply(cursor, maxSize);
+        } else {
+            final int tookAmount = remainingAmount - cursorRule.getAmount(remain);
+            resultCursor = cursorRule.apply(cursor, amount + tookAmount);
+        }
 
-        ItemStack resultCursor = cursorRule.apply(cursor, amount + tookAmount);
         clickResult.setCursor(resultCursor);
         return clickResult;
     }

src/main/java/net/minestom/server/item/ItemStack.java

@@ -41,8 +41,7 @@ public final class ItemStack implements HoverEventSource<HoverEvent.ShowItem> {
         this.material = material;
         this.amount = amount;
         this.meta = meta;
-        this.stackingRule = Objects.requireNonNullElseGet(stackingRule,
+        this.stackingRule = Objects.requireNonNullElseGet(stackingRule, VanillaStackingRule::new);
-                () -> new VanillaStackingRule(64));
     }
 
     @Contract(value = "_ -> new", pure = true)

src/main/java/net/minestom/server/item/ItemStackBuilder.java

@@ -109,10 +109,9 @@ public class ItemStackBuilder {
 
     @Contract(value = "-> new", pure = true)
     public @NotNull ItemStack build() {
-        if (amount <= 0)
+        if (amount > 0)
-            return ItemStack.AIR;
+            return new ItemStack(material, amount, metaBuilder.build(), stackingRule);
-
+        return ItemStack.AIR;
-        return new ItemStack(material, amount, metaBuilder.build(), stackingRule);
     }
 
     private static final class DefaultMeta extends ItemMetaBuilder {

src/main/java/net/minestom/server/item/StackingRule.java

@@ -10,13 +10,7 @@ import java.util.function.IntUnaryOperator;
  * This can be used to mimic the vanilla one (using the displayed item quantity)
  * or a complete new one which can be stored in lore, name, etc...
  */
-public abstract class StackingRule {
+public interface StackingRule {
-
-    private final int maxSize;
-
-    public StackingRule(int maxSize) {
-        this.maxSize = maxSize;
-    }
 
     /**
      * Used to know if two {@link ItemStack} can be stacked together.
@@ -26,16 +20,16 @@ public abstract class StackingRule {
      * @return true if both {@link ItemStack} can be stacked together
      * (without taking their amount in consideration)
      */
-    public abstract boolean canBeStacked(@NotNull ItemStack item1, @NotNull ItemStack item2);
+    boolean canBeStacked(@NotNull ItemStack item1, @NotNull ItemStack item2);
 
     /**
      * Used to know if an {@link ItemStack} can have the size {@code newAmount} applied.
      *
      * @param item      the {@link ItemStack} to check
-     * @param newAmount the desired new amount
+     * @param amount the desired new amount
      * @return true if {@code item} can have its stack size set to newAmount
      */
-    public abstract boolean canApply(@NotNull ItemStack item, int newAmount);
+    boolean canApply(@NotNull ItemStack item, int amount);
 
     /**
      * Changes the size of the {@link ItemStack} to {@code newAmount}.
@@ -46,10 +40,10 @@ public abstract class StackingRule {
      * @return a new {@link ItemStack item} with the specified amount
      */
     @Contract("_, _ -> new")
-    public abstract @NotNull ItemStack apply(@NotNull ItemStack item, int newAmount);
+    @NotNull ItemStack apply(@NotNull ItemStack item, int newAmount);
 
     @Contract("_, _ -> new")
-    public @NotNull ItemStack apply(@NotNull ItemStack item, @NotNull IntUnaryOperator amountOperator) {
+    default @NotNull ItemStack apply(@NotNull ItemStack item, @NotNull IntUnaryOperator amountOperator) {
         return apply(item, amountOperator.applyAsInt(getAmount(item)));
     }
 
@@ -60,14 +54,13 @@ public abstract class StackingRule {
      * @param itemStack the {@link ItemStack} to check the size
      * @return the correct size of {@link ItemStack}
      */
-    public abstract int getAmount(@NotNull ItemStack itemStack);
+    int getAmount(@NotNull ItemStack itemStack);
 
     /**
      * Gets the max size of a stack.
      *
+     * @param itemStack the item to get the max size from
      * @return the max size of a stack
      */
-    public int getMaxSize() {
+    int getMaxSize(@NotNull ItemStack itemStack);
-        return maxSize;
-    }
 }

src/main/java/net/minestom/server/item/rule/VanillaStackingRule.java

@@ -5,11 +5,7 @@ import net.minestom.server.item.StackingRule;
 import net.minestom.server.utils.MathUtils;
 import org.jetbrains.annotations.NotNull;
 
-public class VanillaStackingRule extends StackingRule {
+public class VanillaStackingRule implements StackingRule {
-
-    public VanillaStackingRule(int maxSize) {
-        super(maxSize);
-    }
 
     @Override
     public boolean canBeStacked(@NotNull ItemStack item1, @NotNull ItemStack item2) {
@@ -18,20 +14,23 @@ public class VanillaStackingRule extends StackingRule {
 
     @Override
     public boolean canApply(@NotNull ItemStack item, int newAmount) {
-        return MathUtils.isBetween(newAmount, 0, getMaxSize());
+        return MathUtils.isBetween(newAmount, 0, getMaxSize(item));
     }
 
-    @NotNull
     @Override
-    public ItemStack apply(@NotNull ItemStack item, int newAmount) {
+    public @NotNull ItemStack apply(@NotNull ItemStack item, int amount) {
-        if (newAmount <= 0)
+        if (amount > 0)
-            return ItemStack.AIR;
+            return item.withAmount(amount);
-
+        return ItemStack.AIR;
-        return item.withAmount(newAmount);
     }
 
     @Override
     public int getAmount(@NotNull ItemStack itemStack) {
         return itemStack.getAmount();
     }
+
+    @Override
+    public int getMaxSize(@NotNull ItemStack itemStack) {
+        return itemStack.getMaterial().getMaxDefaultStackSize();
+    }
 }

src/main/java/net/minestom/server/network/netty/NettyServer.java

@@ -135,23 +135,6 @@ public final class NettyServer {
             }
         }
 
-        // Add default allocator settings
-        {
-            if (System.getProperty("io.netty.allocator.numDirectArenas") == null) {
-                System.setProperty("io.netty.allocator.numDirectArenas", String.valueOf(workerThreadCount));
-            }
-
-            if (System.getProperty("io.netty.allocator.numHeapArenas") == null) {
-                System.setProperty("io.netty.allocator.numHeapArenas", String.valueOf(workerThreadCount));
-            }
-
-            if (System.getProperty("io.netty.allocator.maxOrder") == null) {
-                // The default page size is 8192 bytes, a bit shift of 5 makes it 262KB
-                // largely enough for this type of server
-                System.setProperty("io.netty.allocator.maxOrder", "5");
-            }
-        }
-
         bootstrap = new ServerBootstrap()
                 .group(boss, worker)
                 .childOption(ChannelOption.WRITE_BUFFER_WATER_MARK, SERVER_WRITE_MARK)