public static String InventoryToString(Inventory invInventory) {
    String serialization = invInventory.getSize() + ";";
    for (int i = 0; i < invInventory.getSize(); i++) {
      ItemStack is = invInventory.getItem(i);
      if (is != null) {
        String serializedItemStack = new String();

        String isType = String.valueOf(is.getType().getId());
        serializedItemStack += "t@" + isType;

        if (is.getDurability() != 0) {
          String isDurability = String.valueOf(is.getDurability());
          serializedItemStack += ":d@" + isDurability;
        }

        if (is.getAmount() != 1) {
          String isAmount = String.valueOf(is.getAmount());
          serializedItemStack += ":a@" + isAmount;
        }

        Map<Enchantment, Integer> isEnch = is.getEnchantments();
        if (isEnch.size() > 0) {
          for (Entry<Enchantment, Integer> ench : isEnch.entrySet()) {
            serializedItemStack += ":e@" + ench.getKey().getId() + "@" + ench.getValue();
          }
        }

        serialization += i + "#" + serializedItemStack + ";";
      }
    }
    return serialization;
  }
Example #2
0
 // Returns true if this item matches the item from a recipe
 public static boolean ingredientsMatch(ItemStack usedItem, ItemStack recipeItem) {
   if (!recipeItem.getType().equals(usedItem.getType())) {
     return false;
   }
   return recipeItem.getDurability() == -1
       || recipeItem.getDurability() == usedItem.getDurability();
 }
Example #3
0
 @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
 public void onEntityRightClick(PlayerInteractEntityEvent event) {
   QuestManager qm = Quester.qMan;
   Player player = event.getPlayer();
   Quest quest = qm.getPlayerQuest(player.getName());
   if (quest != null) {
     if (!quest.allowedWorld(player.getWorld().getName().toLowerCase())) return;
     List<Objective> objs = quest.getObjectives();
     Entity entity = event.getRightClicked();
     ItemStack item = player.getItemInHand();
     for (int i = 0; i < objs.size(); i++) {
       if (objs.get(i).getType().equalsIgnoreCase("DYE")) {
         if (!qm.isObjectiveActive(player, i)) {
           continue;
         }
         DyeObjective obj = (DyeObjective) objs.get(i);
         if (entity.getType() == EntityType.SHEEP) {
           Sheep sheep = (Sheep) entity;
           if (item.getType() == Material.INK_SACK
               && obj.checkDye(15 - item.getDurability())
               && sheep.getColor().getDyeData() != (15 - item.getDurability())) {
             qm.incProgress(player, i);
             return;
           }
         }
       }
     }
   }
 }
Example #4
0
  public static int countItemsInInventory(PlayerInventory inventory, ItemStack item) {
    int totalAmount = 0;
    boolean isDurable = Items.itemByStack(item).isDurable();

    for (Integer i : inventory.all(item.getType()).keySet()) {
      ItemStack thisStack = inventory.getItem(i);
      if (!isDurable && thisStack.getDurability() != item.getDurability()) {
        continue;
      }
      totalAmount += thisStack.getAmount();
    }
    return totalAmount;
  }
  private boolean containsItem(
      Collection<? extends ItemStack> items, ItemStack item, boolean ingredient) {
    for (ItemStack i : items) {
      if (i != null
          && i.getTypeId() == item.getTypeId()
          && (item.getDurability() == Vanilla.DATA_WILDCARD
              || i.getDurability() == item.getDurability())
          && (ingredient || item.getAmount() == 1 || item.getAmount() == i.getAmount())) {
        return true;
      }
    }

    return false;
  }
Example #6
0
  @Command(
      command = "iteminfo",
      aliases = {"iinfo"},
      description = "Shows information about items",
      syntax =
          "/iteminfo §2(what's the item in hand?) \n"
              + "/iteminfo §712§f §2(what's the item with ID §712§2?) \n"
              + "/iteminfo §7log§f §2(what's the item ID of §7LOG§2?)")
  public static boolean itemInfo(CommandSender sender, String currentAlias, String[] args) {
    ItemStack item;

    if (args.length == 0) {
      if (!(sender instanceof Player)) {
        return false;
      }

      item = ((Player) sender).getItemInHand();
    } else {
      item = MaterialUtil.getItem(StringUtil.joinArray(args));
    }

    if (item == null || item.getType() == Material.AIR) {
      return false;
    }

    String durability =
        (item.getDurability() != 0 ? ChatColor.DARK_GREEN + ":" + item.getDurability() : "");

    String enchantmentString = MaterialUtil.Enchantments.encodeEnchantment(item.getEnchantments());
    String enchantment =
        (enchantmentString != null ? ChatColor.DARK_AQUA + "-" + enchantmentString : "");

    String itemName = MaterialUtil.getName(item);

    EventUtils.sendMessage(new MessageEvent("iteminfo"), sender);

    sender.sendMessage(
        ChatColor.GRAY
            + itemName
            + ChatColor.WHITE
            + "     "
            + item.getTypeId()
            + durability
            + enchantment);

    sendEnchantments(item.getEnchantments(), sender);

    return true;
  }
Example #7
0
	@Override
	protected void run(final CommandSender sender, final String commandLabel, final String[] args) throws Exception
	{
		ItemStack itemStack = null;
		if (args.length < 1)
		{
			if (sender instanceof Player)
			{
				itemStack = ((Player)sender).getItemInHand();
			}
			if (itemStack == null)
			{
				throw new NotEnoughArgumentsException();
			}
		}
		else
		{
			itemStack = ess.getItemDb().get(args[0]);
		}
		sender.sendMessage(itemStack.getType().toString() + "- " + itemStack.getTypeId() + ":" + Integer.toString(itemStack.getData().getData()));


		if (itemStack.getType() != Material.AIR)
		{
			int maxuses = itemStack.getType().getMaxDurability();
			int durability = ((maxuses + 1) - itemStack.getDurability());
			if (maxuses != 0)
			{
				sender.sendMessage(_("durability", Integer.toString(durability)));
			}
		}
	}
  public void excute(Minecart minecart, MinecartControl mc, String... job) {

    if (!(minecart instanceof InventoryHolder) || minecart instanceof PoweredMinecart) {
      return;
    }

    InventoryHolder invMinecart = (InventoryHolder) minecart;

    HashSet<ItemStack> itemStacks = mc.getUtils().getItemTransferUtil().getItemStacks(job[0]);

    for (ItemStack itemStack : itemStacks) {

      if (itemStack.getAmount() == 0) {
        return;
      }
      for (Iterator<Recipe> irt = Bukkit.recipeIterator(); irt.hasNext(); ) {
        Recipe r = irt.next();
        if (r instanceof ShapedRecipe) {
          ShapedRecipe recipe = ((ShapedRecipe) r);
          if (recipe.getResult().getType() == itemStack.getType()
              && recipe.getResult().getDurability() == itemStack.getDurability()) {
            System.out.println(recipe.getResult().getType().name());
            int y = 0;
            while (y < itemStack.getAmount()) {
              crafting(recipe, invMinecart);
              y += recipe.getResult().getAmount();
            }
          }
        }
      }
    }
  }
  @EventHandler
  public static void onTransactionLogToDB(TransactionEvent event) {
    if (!Config.getBoolean(LOG_TO_DATABASE) && !Config.getBoolean(GENERATE_STATISTICS_PAGE)) {
      return;
    }

    double pricePerStack = event.getPrice() / event.getStock().length;

    for (ItemStack item : event.getStock()) {
      Transaction transaction = new Transaction();

      transaction.setAmount(item.getAmount());

      transaction.setItemID(item.getTypeId());
      transaction.setItemDurability(item.getDurability());

      transaction.setPrice((float) pricePerStack);

      transaction.setShopOwner(event.getOwner().getName());
      transaction.setShopUser(event.getClient().getName());

      transaction.setSec(System.currentTimeMillis() / 1000);
      transaction.setBuy(event.getTransactionType() == BUY);

      Queue.addToQueue(transaction);
    }
  }
  public void drop(Location loc) {
    PartyRoom.debug(
        owner.getName()
            + " got OwnedItemStack of type "
            + item.getType()
            + ":"
            + item.getDurability()
            + " at "
            + Utilities.LocToString(loc));

    final Item itemEntity = loc.getWorld().dropItem(loc, item);
    itemEntity.setMetadata("owner", new FixedMetadataValue(PartyRoom.getPlugin(), owner.getName()));
    new BukkitRunnable() {
      int cycle = 0;

      public void run() {
        if (itemEntity.isDead() || itemEntity == null) {
          itemEntity.removeMetadata("owner", PartyRoom.getPlugin());
          this.cancel();
          return;
        }
        if (cycle > 60) {
          itemEntity.removeMetadata("owner", PartyRoom.getPlugin());
          this.cancel();
          return;
        }
        cycle++;
      }
    }.runTaskTimer(PartyRoom.getPlugin(), 20L, 20L);
  }
Example #11
0
 @SuppressWarnings({
   "rawtypes",
   "unchecked"
 }) // I can't parameterize this either; it scares the compiler
 private static <T extends VariantData<U, T, ?>, U extends CatalogType> T getItemData(
     ItemStack item, Class<T> type, BiMap<U, Integer> map) {
   int damage = item.getDurability();
   if (!map.containsValue(damage)) {
     throw new UnsupportedOperationException();
   }
   // no idea why a typecast is necessary here but excluding it makes javac angry
   @SuppressWarnings("RedundantCast")
   T data =
       (T)
           Pore.getGame()
               .getRegistry()
               .createItemBuilder()
               .itemType(MaterialConverter.asItem(item.getType()))
               .quantity(1)
               .build()
               .getOrCreate(type)
               .get();
   data.type().set(map.inverse().get(damage));
   return data;
 }
  private Collection<ItemStack> getStackOnRecipeMatch(final Recipe recipe, final ItemStack stack) {
    final Collection<ItemStack> inputList;

    if (recipe instanceof ShapedRecipe) {
      ShapedRecipe sRecipe = (ShapedRecipe) recipe;
      inputList = sRecipe.getIngredientMap().values();
    } else if (recipe instanceof ShapelessRecipe) {
      ShapelessRecipe slRecipe = (ShapelessRecipe) recipe;
      inputList = slRecipe.getIngredientList();
    } else {
      return null;
    }

    boolean match = true;
    Iterator<ItemStack> iter = inputList.iterator();
    while (iter.hasNext()) {
      ItemStack inputSlot = iter.next();
      if (inputSlot == null) {
        iter.remove();
        continue;
      }

      if (inputSlot.getDurability() == Short.MAX_VALUE) {
        inputSlot.setDurability((short) 0);
      }
      if (!inputSlot.isSimilar(stack)) {
        match = false;
      }
    }

    if (match) {
      return inputList;
    }
    return null;
  }
  @Override
  public void serializeItemStack(DataOutputStream output, ItemStack stack) throws IOException {
    // Speed things up if the workaround is not required
    if (!isRequired()) {
      super.serializeItemStack(output, stack);
      return;
    }
    NbtCompound tag =
        stack != null && stack.getType() != Material.AIR
            ? NbtFactory.asCompound(NbtFactory.fromItemTag(stack))
            : null;

    // Note that we can't write the stack data directly, as 1.8 switched to sending a
    // item name instead of an item ID.
    if (tag != null) {
      ByteArrayOutputStream byteStream = new ByteArrayOutputStream();
      DataOutputStream dataStream = new DataOutputStream(byteStream);
      ItemStack withoutTag =
          new ItemStack(stack.getType(), stack.getAmount(), stack.getDurability());

      // This will write the stack as normal, without its tag compound and the tag field length
      super.serializeItemStack(dataStream, withoutTag);
      output.write(byteStream.toByteArray(), 0, byteStream.size() - 2);
      serializeCompound(output, tag);

    } else {
      // Write the stack as normal
      super.serializeItemStack(output, stack);
    }
  }
Example #14
0
  /**
   * Converts specified inventory into inventory string and stores it. Previous inventory string
   * will be deleted.
   *
   * @param playerinv inventory that will be stored
   */
  public void storeInventory(PlayerInventory playerinv) {
    String inv = "";
    for (int i = 0; i < 40; i++) {
      ItemStack item = playerinv.getItem(i);
      if (item == null || item.getType() == Material.AIR) continue;

      String enchantString = "";
      for (Entry<Enchantment, Integer> e : item.getEnchantments().entrySet())
        enchantString +=
            String.valueOf(e.getKey().getId()) + ":" + String.valueOf(e.getValue()) + "*";
      if (enchantString.length() > 1)
        enchantString = enchantString.substring(0, enchantString.length() - 1);

      inv +=
          String.valueOf(item.getTypeId())
              + ","
              + String.valueOf(item.getAmount())
              + ","
              + String.valueOf(item.getDurability())
              + ","
              + enchantString
              + ";";
    }
    inventory = inv;
    InputOutput.UpdatePrisoner(this);
  }
  /**
   * Apply the hard stone game mechanic
   *
   * <p>Players who mine stone below a certain depth increase their hunger
   *
   * @param blockY The Y coordinate of the mined block
   * @param tool The tool that was used to mine the block
   */
  public void doHardStone(int blockY, ItemStack tool) {

    // Calculate applicable durability penalty

    short penalty;

    if (tool.getType() == Material.GOLD_PICKAXE) {
      penalty = UhcMatch.DURABILITY_PENALTY_GOLD;
    } else if (tool.getType() == Material.WOOD_PICKAXE) {
      penalty = UhcMatch.DURABILITY_PENALTY_WOOD;
    } else if (tool.getType() == Material.STONE_PICKAXE) {
      penalty = UhcMatch.DURABILITY_PENALTY_STONE;
    } else if (tool.getType() == Material.IRON_PICKAXE) {
      penalty = UhcMatch.DURABILITY_PENALTY_IRON;
    } else if (tool.getType() == Material.DIAMOND_PICKAXE) {
      penalty = UhcMatch.DURABILITY_PENALTY_DIAMOND;
    } else return;

    // Warn the player the first time

    if (!warnedHardStone) {
      player.sendMessage(
          ChatColor.GOLD
              + "Warning! Mining smoothstone will wear out your tools more quickly than in normal Minecraft.");
      warnedHardStone = true;
    }

    // Apply durability cost

    tool.setDurability((short) (tool.getDurability() + penalty));
  }
  public void updateSpectatorOnInventory(Player spec) {
    Player player = getPlayer().getPlayer();
    if (player == null) return;

    PlayerInventory inv = player.getInventory();
    int goldIngots = 0;
    int goldenApples = 0;
    int notchApples = 0;
    for (ItemStack is : inv.getContents()) {
      if (is != null) {
        if (is.getType() == Material.GOLD_INGOT) goldIngots += is.getAmount();
        if (is.getType() == Material.GOLD_BLOCK) goldIngots += is.getAmount() * 9;
        if (is.getType() == Material.GOLD_NUGGET) goldIngots += is.getAmount() / 9;

        if (is.getType() == Material.GOLDEN_APPLE) {
          if (is.getDurability() == 0) goldenApples += is.getAmount();
          if (is.getDurability() == 1) notchApples += is.getAmount();
        }
      }
    }

    PluginChannelUtils.messageSpectator(
        spec, "player", getName(), "itemcount", "266", Integer.toString(goldIngots));
    PluginChannelUtils.messageSpectator(
        spec, "player", getName(), "itemcount", "322,0", Integer.toString(goldenApples));
    PluginChannelUtils.messageSpectator(
        spec, "player", getName(), "itemcount", "322,1", Integer.toString(notchApples));
  }
Example #17
0
 @SuppressWarnings("deprecation")
 @Override
 protected void execute(Event e) {
   Location pos1 = location1.getSingle(e);
   Location pos2 = location2.getSingle(e);
   EditSession session = editSession.getSingle(e);
   ItemStack[] blocks = blockList.getAll(e);
   RandomPattern random = new RandomPattern();
   if (session == null) return;
   for (ItemStack b : blocks) {
     if (b.getType().isBlock()) {
       random.add(new BlockPattern(new BaseBlock(b.getTypeId(), b.getDurability())), 50);
     }
   }
   try {
     session.makeWalls(
         new CuboidRegion(
             (World) BukkitUtil.getLocalWorld(pos1.getWorld()),
             BukkitUtil.toVector(pos1),
             BukkitUtil.toVector(pos2)),
         Patterns.wrap(random));
     session.flushQueue();
   } catch (WorldEditException ex) {
     if (ex instanceof MaxChangedBlocksException) return;
     else ex.printStackTrace();
   }
 }
 public void removePearlFromContainer(PrisonPearl pp) {
   Inventory inv[] = new Inventory[2];
   if (HolderStateToInventory(pp, inv) != HolderStateToInventory_SUCCESS) {
     return;
   }
   Inventory real_inv = null;
   int pearlslot = -1;
   int pp_id = pp.getID();
   for (int inv_idx = 0; inv_idx <= 1 && pearlslot == -1; ++inv_idx) {
     if (inv[inv_idx] == null) {
       continue;
     }
     HashMap<Integer, ? extends ItemStack> inv_contents = inv[inv_idx].all(Material.ENDER_PEARL);
     for (int inv_slot : inv_contents.keySet()) {
       ItemStack slot_item = inv_contents.get(inv_slot);
       if (slot_item.getDurability() == pp_id) {
         real_inv = inv[inv_idx];
         pearlslot = inv_slot;
         break;
       }
     }
   }
   if (real_inv == null || pearlslot == -1) {
     return;
   }
   real_inv.setItem(pearlslot, new ItemStack(Material.ENDER_PEARL));
 }
Example #19
0
 public static Potion fromItemStack(ItemStack item) {
   Validate.notNull(item, "item cannot be null");
   if (item.getType() != Material.POTION) {
     throw new IllegalArgumentException("item is not a potion");
   }
   return fromDamage(item.getDurability());
 }
Example #20
0
 // Returns true if this ingredient cares about durability
 public boolean hasExactData(ItemStack item) {
   for (ItemStack ingredient : ingredients) {
     if (ingredient.getType().equals(item.getType())) {
       return ingredient.getDurability() != -1;
     }
   }
   return true;
 }
Example #21
0
 @Override
 public void afterPlace(GlowPlayer player, GlowBlock block, ItemStack holding) {
   GlowBanner banner = (GlowBanner) block.getState();
   banner.setBase(DyeColor.getByDyeData((byte) holding.getDurability()));
   BannerMeta meta = (BannerMeta) holding.getItemMeta();
   banner.setPattern(meta.getPattern());
   banner.update();
 }
Example #22
0
 private ItemStack cloneItemStack(ItemStack source) {
   if (source == null) { // sanity check
     return null;
   }
   return new ItemStack(
       source.getType(),
       source.getAmount(),
       source.getDurability(),
       (source.getData() != null ? source.getData().getData() : null));
 }
Example #23
0
 /**
  * Creates a new item stack derived from the specified stack
  *
  * @param stack the stack to copy
  * @throws IllegalArgumentException if the specified stack is null or returns an item meta not
  *     created by the item factory
  */
 public ItemStack(final ItemStack stack) throws IllegalArgumentException {
   Validate.notNull(stack, "Cannot copy null stack");
   this.type = stack.getTypeId();
   this.amount = stack.getAmount();
   this.durability = stack.getDurability();
   this.data = stack.getData();
   if (stack.hasItemMeta()) {
     setItemMeta0(stack.getItemMeta(), getType0());
   }
 }
Example #24
0
 /**
  * Check if the ItemStack is a Drug
  *
  * @param item The ItemStack
  * @return If the ItemStack is a Drug
  */
 public boolean isDrug(ItemStack item) {
   for (Drug drug : getDrugs()) {
     Material mat = drug.getItemStack().getType();
     short dmg = drug.getItemStack().getDurability();
     if (mat.name().equalsIgnoreCase(item.getType().name()) && dmg == item.getDurability()) {
       return true;
     }
   }
   return false;
 }
Example #25
0
 /**
  * Get Drug instance from ItemStack
  *
  * @param item The ItemStack
  * @return The Drug instance
  */
 public Drug getDrug(ItemStack item) {
   for (Drug drug : getDrugs()) {
     Material drugMat = drug.getItemStack().getType();
     short drugDmg = drug.getItemStack().getDurability();
     if (drugMat == item.getType() && drugDmg == item.getDurability()) {
       return drug;
     }
   }
   return null;
 }
 @SuppressWarnings("deprecation")
 public void run() {
   for (Player p : c.getServer().getOnlinePlayers()) {
     for (ItemStack is : p.getInventory().getContents()) {
       if (is == null || is.getType() == Material.AIR || !is.hasItemMeta()) continue;
       if (!is.getItemMeta().hasLore()) continue;
       if (!c.hasCustomEnchant(is.getItemMeta().getLore())) continue;
       boolean b = false;
       for (String s : is.getItemMeta().getLore()) {
         if (!c.isCustomEnchant(s)) continue;
         if (s.startsWith(ChatColor.RESET + "Repair ")) b = true;
       }
       if (!b) continue;
       if (is.getDurability() > 0) is.setDurability((short) (is.getDurability() - 1));
     }
     boolean hasChestplateOn = false;
     for (ItemStack is : p.getInventory().getArmorContents()) {
       if (is == null || !is.getType().name().endsWith("CHESTPLATE") || !is.hasItemMeta())
         continue;
       if (!is.getItemMeta().hasLore()) continue;
       if (!c.hasCustomEnchant(is.getItemMeta().getLore())) continue;
       boolean b = false;
       for (String s : is.getItemMeta().getLore()) {
         if (!c.isCustomEnchant(s)) continue;
         if (s.startsWith(ChatColor.RESET + "Flying ")) b = true;
       }
       if (!b) continue;
       if (!hasChestplateOn) {
         if (!p.isFlying()) {
           p.sendMessage(ChatColor.GOLD + "Flying enabled!");
         }
         p.setAllowFlight(true);
         p.setFlying(true);
         hasChestplateOn = true;
       }
     }
     if (!hasChestplateOn && p.getGameMode() != GameMode.CREATIVE && p.isFlying()) {
       p.setFlying(false);
       p.setAllowFlight(false);
     }
   }
 }
Example #27
0
  /**
   * Get a block.
   *
   * @param id
   */
  @Override
  public void fetchItem(BaseItem item) throws BlockBagException {
    final int id = item.getType();
    final int damage = item.getDamage();
    int amount = (item instanceof BaseItemStack) ? ((BaseItemStack) item).getAmount() : 1;
    assert (amount == 1);
    boolean usesDamageValue = ItemType.usesDamageValue(id);

    if (id == BlockID.AIR) {
      throw new IllegalArgumentException("Can't fetch air block");
    }

    loadInventory();

    boolean found = false;

    for (int slot = 0; slot < items.length; ++slot) {
      ItemStack bukkitItem = items[slot];

      if (bukkitItem == null) {
        continue;
      }

      if (bukkitItem.getTypeId() != id) {
        // Type id doesn't fit
        continue;
      }

      if (usesDamageValue && bukkitItem.getDurability() != damage) {
        // Damage value doesn't fit.
        continue;
      }

      int currentAmount = bukkitItem.getAmount();
      if (currentAmount < 0) {
        // Unlimited
        return;
      }

      if (currentAmount > 1) {
        bukkitItem.setAmount(currentAmount - 1);
        found = true;
      } else {
        items[slot] = null;
        found = true;
      }

      break;
    }

    if (!found) {
      throw new OutOfBlocksException();
    }
  }
Example #28
0
  private void repairItem(final ItemStack item) throws Exception {
    final Material material = Material.getMaterial(item.getTypeId());
    if (material.isBlock() || material.getMaxDurability() < 0) {
      throw new Exception(Util.i18n("repairInvalidType"));
    }

    if (item.getDurability() == 0) {
      throw new Exception(Util.i18n("repairAlreadyFixed"));
    }

    item.setDurability((short) 0);
  }
Example #29
0
 public static void transferDamage(ItemStack stack, JsonObject json, boolean stack2json) {
   // Durability is a weird name since it is the amount of damage.
   if (stack2json) {
     int damage = stack.getDurability();
     if (damage == DEFAULT_DAMAGE) return;
     json.addProperty(DAMAGE, damage);
   } else {
     JsonElement element = json.get(DAMAGE);
     if (element == null) return;
     stack.setDurability(element.getAsShort());
   }
 }
Example #30
0
 /**
  * add an ItemStack to an array
  *
  * @param items
  * @param toAdd
  * @param extraStack whether to allow some nonstackable items to stack
  * @return
  */
 public static ItemStack add(ItemStack[] items, ItemStack toAdd, boolean extraStack) {
   ItemStack ret = toAdd.clone();
   int mx = !extraStack || noStack.contains(toAdd.getTypeId()) ? JItems.getMaxStack(toAdd) : 64;
   boolean firstRun = true;
   for (int i = 0; i < items.length; ++i) {
     if (!firstRun && (items[i] == null || items[i].getAmount() == 0)) {
       if (items[i] == null) {
         items[i] = toAdd;
       } else {
         items[i].setTypeId(toAdd.getTypeId());
         items[i].setDurability(toAdd.getDurability());
         items[i].addEnchantments(toAdd.getEnchantments());
       }
       items[i].setAmount(ret.getAmount());
       ret.setAmount(0);
       return ret;
     } else if (items[i] != null
         && items[i].getTypeId() == toAdd.getTypeId()
         && items[i].getDurability()
             == toAdd
                 .getDurability() // (!JItems.hasData(toAdd.getTypeId()) ||
                                  // items[i].getData().getData() == toAdd.getData().getData())
         && sameEnchants(items[i], toAdd)
         && items[i].getAmount() < mx) {
       // on first run, look for other stacks in array that could be incremented instead
       if (items[i].getAmount() + ret.getAmount() <= mx) {
         items[i].setAmount(items[i].getAmount() + ret.getAmount());
         ret.setAmount(0);
         return ret;
       } else {
         ret.setAmount(ret.getAmount() - (mx - items[i].getAmount()));
         items[i].setAmount(mx);
       }
     } else if (firstRun && i + 1 >= items.length) {
       firstRun = false;
       i = -1; // negative, because gets incremented again
     }
   }
   return ret;
 }