/** * Generate a random set of items. * * @param random the PRNG to use * @return an immutable collection of randomly-generated items */ public Collection<ItemStack> getItemStacks(Random random) { int minAmount = stack.getAmount(); int amount = random.nextInt(maxAmount - minAmount + 1) + minAmount; if (amount <= stack.getMaxStackSize()) { ItemStack adjustedStack = stack.clone(); adjustedStack.setAmount(amount); return Collections.unmodifiableList(Arrays.asList(adjustedStack)); } else { ItemStack[] stacks = new ItemStack[amount]; for (int i = 0; i < amount; i++) { stacks[i] = stack.clone(); stacks[i].setAmount(1); } return Collections.unmodifiableList(Arrays.asList(stacks)); } } }
maxStack.setAmount(stack.getMaxStackSize()); int firstEmpty = -1; for (int s = 0; s < slots.length && stack.getAmount() > 0; s += 2) { int maxStackSize = Math.min(currentStack.getMaxStackSize(), getMaxStackSize()); int transfer = Math.min(stack.getAmount(), maxStackSize - amount); if (transfer > 0) { if (stack.getAmount() > stack.getMaxStackSize()) { setItem(firstEmpty, maxStack); stack.setAmount(stack.getAmount() - stack.getMaxStackSize()); } else { ItemStack finalStack = stack.clone();
private boolean isBurnable() { GlowFurnaceInventory inv = (GlowFurnaceInventory) getInventory(); if ((burnTime != 0 || !InventoryUtil.isEmpty(inv.getFuel())) && !InventoryUtil .isEmpty(inv.getSmelting())) { if ((InventoryUtil.isEmpty(inv.getFuel()) || InventoryUtil.isEmpty(inv.getSmelting())) && burnTime == 0) { return false; } CraftingManager cm = ((GlowServer) ServerProvider.getServer()).getCraftingManager(); if (burnTime != 0 || cm.isFuel(inv.getFuel().getType())) { Recipe recipe = cm.getFurnaceRecipe(inv.getSmelting()); if (recipe != null && (InventoryUtil.isEmpty(inv.getResult()) || inv.getResult().getType().equals(recipe.getResult().getType()) && inv.getResult().getAmount() + recipe.getResult().getAmount() <= recipe .getResult().getMaxStackSize())) { return true; } } } return false; } }
if (cursor.getAmount() + 1 == cursor.getMaxStackSize()) { } else if (cursor.getAmount() < cursor.getMaxStackSize()) { if (message.getMode() == 0 && slotItem.isSimilar(cursor)) { if (!InventoryUtil.isEmpty(slotItem) && cursorAmount + slotItem.getAmount() <= slotItem.getMaxStackSize()) { .min(cursor.getMaxStackSize() - cursor.getAmount(), slotItem.getAmount()); view.setItem(viewSlot, amountOrEmpty(slotItem, slotItem.getAmount() - pickUp)); player.setItemOnCursor(amountOrEmpty(cursor, cursor.getAmount() + pickUp));
/** * Get the max size an item stack is allowed to stack to while respecting the STACK_TO_64 config property * * @param item The item to get the max stacksize of * @return The max stacksize of the item stack's type or 64 if STACK_TO_64 is enabled */ public static int getMaxStackSize(ItemStack item) { return Properties.STACK_TO_64 ? 64 : item.getMaxStackSize(); }
@Override public int maxStackSize() { if(is == null) { return 0; } return is.getMaxStackSize(); }
@Override public LuaValue call() { return CoerceJavaToLua.coerce(item.getMaxStackSize()); } });
/** * Adds an item to the inventor * * @param item Item to add * @param inventory Inventory * @return Number of leftover items */ public static int add(ItemStack item, Inventory inventory) { Map<Integer, ItemStack> leftovers = inventory.addItem(item.clone()); // item needs to be cloned as cb changes the amount of the stack size if (!leftovers.isEmpty()) { for (Iterator<ItemStack> iterator = leftovers.values().iterator(); iterator.hasNext(); ) { ItemStack left = iterator.next(); int amountLeft = addManually(left, inventory, left.getMaxStackSize()); if (amountLeft == 0) { iterator.remove(); } else { left.setAmount(amountLeft); } } } return countItems(leftovers); }
public boolean canContainItem(Inventory inv, ItemStack item) { int space = 0; for (ItemStack stack : inv.getContents()) { if (stack == null) { space += item.getMaxStackSize(); } else if (stack.getType() == item.getType() && stack.getDurability() == item.getDurability()) { space += item.getMaxStackSize() - stack.getAmount(); } } return space >= item.getAmount(); }
public boolean canContainItem(Inventory inv, ItemStack item) { int space = 0; for (ItemStack stack : inv.getContents()) { if (stack == null) { space += item.getMaxStackSize(); } else if (stack.getType() == item.getType() && stack.getDurability() == item.getDurability()) { space += item.getMaxStackSize() - stack.getAmount(); } } return space >= item.getAmount(); }
/** * Adds an item to the inventory with given maximum stack size * * @param item Item to add * @param inventory Inventory * @param maxStackSize Maximum item's stack size * @return Number of leftover items */ public static int add(ItemStack item, Inventory inventory, int maxStackSize) { if (item.getAmount() < 1) { return 0; } if (maxStackSize == item.getMaxStackSize()) { return add(item, inventory); } return addManually(item, inventory, maxStackSize); }
protected ItemStack[] pickFromTreasures(MaterialList materials, Odds odds, int maxCount, int maxStack) { int count = maxCount > 0 ? odds.getRandomInt(maxCount) + 1 : 0; // make room ItemStack[] items = new ItemStack[count]; // populate for (int i = 0; i < count; i++) { ItemStack itemStack = new ItemStack(materials.getRandomMaterial(odds)); itemStack.setAmount(itemStack.getMaxStackSize() == 1 ? 1 : odds.getRandomInt(maxStack) + 1); items[i] = itemStack; } // all done return items; }
Denomination denom = it.previous(); ItemStack stack = new ItemStack(denom.getKey().type); int stacksize = stack.getMaxStackSize();
/** * Calculates the space available to accommodate a new item stack. This method takes empty slots and existing item * stacks of the same type into account. * * @param player * @param newItemStack * @return the available space for the item */ int getInventoryAvailableSpace(Player player, ItemStack newItemStack) { int availableSpace = 0; // Get all similar item stacks with a similar material in the player's inventory. HashMap<Integer, ? extends ItemStack> inventoryItemStackMap = player.getInventory().all(newItemStack.getType()); // If matching item stack, add remaining space. for (ItemStack currentItemStack : inventoryItemStackMap.values()) { if (newItemStack.isSimilar(currentItemStack)) { availableSpace += (newItemStack.getMaxStackSize() - currentItemStack.getAmount()); } } ItemStack[] storageContents = serverVersion >= 9 ? player.getInventory().getStorageContents() : player.getInventory().getContents(); // Get all empty slots in the player's inventory. for (ItemStack currentItemStack : storageContents) { if (currentItemStack == null) { availableSpace += newItemStack.getMaxStackSize(); } } return availableSpace; }
if (oItem == null) int toAdd = Math.min(item.getAmount(), item.getMaxStackSize()); items[i] = item.clone(); items[i].setAmount(toAdd); item.setAmount(item.getAmount() - toAdd); else if (item.isSimilar(oItem) && oItem.getAmount() < oItem.getMaxStackSize()) int toAdd = Math.min(item.getAmount(), item.getMaxStackSize() - oItem.getAmount()); oItem.setAmount(oItem.getAmount() + toAdd); item.setAmount(item.getAmount() - toAdd);
if (item.isSimilar(itemStack)) { if (amount + itemStack.getAmount() <= itemStack.getMaxStackSize()) { } else { amount -= itemStack.getMaxStackSize() - itemStack.getAmount(); itemStack.setAmount(itemStack.getMaxStackSize());
if (item.getAmount() != item.getMaxStackSize()) { ItemStack newItemStack = new ItemStack(item); newItemStack.setAmount(item.getAmount() + 1);
if (denom.getValue() <= remaining) { ItemStack stack = new ItemStack(denom.getKey().type); int stacksize = stack.getMaxStackSize(); long denomItemCount = denom.getValue() > 0 ? remaining / denom.getValue() : 0;
@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onSmelt(FurnaceSmeltEvent e) { if (BlockStorage.check(e.getBlock()) != null && BlockStorage.check(e.getBlock()) instanceof EnhancedFurnace) { EnhancedFurnace furnace = (EnhancedFurnace) BlockStorage.check(e.getBlock()); Furnace f = (Furnace) e.getBlock().getState(); int amount = f.getInventory().getSmelting().getType().toString().endsWith("_ORE") ? furnace.getOutput(): 1; ItemStack output = RecipeCalculator.getSmeltedOutput(f.getInventory().getSmelting().getType()); ItemStack result = f.getInventory().getResult(); if (result != null) result = result.clone(); f.getInventory().setResult(null); if (result != null) f.getInventory().setResult(new CustomItem(result, result.getAmount() + amount > result.getMaxStackSize() ? result.getMaxStackSize(): result.getAmount() + amount)); else f.getInventory().setResult(new CustomItem(output, output.getAmount() + amount > output.getType().getMaxStackSize() ? output.getType().getMaxStackSize(): output.getAmount() + amount)); } }
for (int i = 0; i < this.getSize(); i++) { if (getItem(i) == null) { if (itemAdd.getAmount() <= itemAdd.getMaxStackSize()) { setItem(i, CraftItemStack.asNMSCopy(itemAdd.clone())); itemAdd.setAmount(0);