Java ItemStack.isSimilar方法代码示例

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
public boolean tryToSaveSlot(int slot) {
    Inventory inv = player.getInventory();
    ItemStack item = inv.getItem(slot);
    if (item == null)
        return true;
    ListIterator<ItemStack> i = inv.iterator();
    while (i.hasNext()) {
        int ind = i.nextIndex();
        ItemStack itm = i.next();
        if (ind == slot || (ind < 9 && hotbarsBySlot[ind] != null))
            continue;
        if(itm == null) {
            i.set(item);
            return true;
        } else if (itm.isSimilar(item)) {
            int free = itm.getAmount() - itm.getMaxStackSize();
            if(item.getAmount() > free) {
                itm.setAmount(itm.getMaxStackSize());
            } else {
                itm.setAmount(itm.getAmount() + free);
                return true;
            }
        }
    }
    return false;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
@Override
public boolean isSimilar(ItemStack stack) {
    if (stack == null) {
        return false;
    }
    if (stack == this) {
        return true;
    }
    if (!(stack instanceof CraftItemStack)) {
        return stack.getClass() == ItemStack.class && stack.isSimilar(this);
    }

    CraftItemStack that = (CraftItemStack) stack;
    if (handle == that.handle) {
        return true;
    }
    if (handle == null || that.handle == null) {
        return false;
    }
    if (!(that.getTypeId() == getTypeId() && getDurability() == that.getDurability())) {
        return false;
    }
    return hasItemMeta() ? that.hasItemMeta() && handle.stackTagCompound.equals(that.handle.stackTagCompound) : !that.hasItemMeta();
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
public static boolean takeOneItem(Player p, ItemStack item) {
    for (int k = 0; k < p.getInventory().getSize(); k++) {
        ItemStack i = p.getInventory().getItem(k);
        if (i != null && i.isSimilar(item)) {
            if (i.getAmount() > 1) {
                i.setAmount(i.getAmount() - 1);
                p.getInventory().setItem(k, i);
                p.updateInventory();
            } else {
                i.setType(Material.AIR);
                i.setAmount(0);
                p.getInventory().setItem(k, null);
            }
            return true;
        }
    }
    return false;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
public static boolean takeItem(Inventory inv, ItemStack item, int takeAmount) {
    Set<Integer> removeSlots = new HashSet<>(takeAmount);
    for (int i = 0; i < inv.getSize(); i++) {
        ItemStack elemItem = inv.getItem(i);
        if (elemItem == null || elemItem.getType() == Material.AIR
                || !elemItem.isSimilar(item))
            continue;

        int amount = elemItem.getAmount();
        if (takeAmount > amount) {
            takeAmount -= amount;
            removeSlots.add(i);
        } else {
            if (takeAmount < amount) {
                elemItem.setAmount(amount - takeAmount);
            } else {
                removeSlots.add(i);
            }
            removeSlots.forEach(inv::clear);
            return true;
        }
    }
    return false;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
@EventHandler
  public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
      Player p = event.getPlayer();
      Entity e = event.getRightClicked();
int slot = p.getInventory().getHeldItemSlot();
if(slot >= 0 && slot < 9){
	ItemStack itemInHand = p.getInventory().getContents()[slot];
	if(itemInHand != null && itemInHand.getType() != Material.AIR && itemInHand.isSimilar(SelectorLayout.getSelectorItem())){
		new SelectorMenu(p, 0).open(p);
		event.setCancelled(true);
		return;
	}
      }

      if (ReflectionUtil.getEntityHandle(e) instanceof IEntityPet) {
          IPet pet = ((IEntityPet) ReflectionUtil.getEntityHandle(e)).getPet();
          event.setCancelled(true);
          PetInteractEvent iEvent = new PetInteractEvent(pet, p, PetInteractEvent.Action.RIGHT_CLICK, false);
          EchoPet.getPlugin().getServer().getPluginManager().callEvent(iEvent);
          if (!iEvent.isCancelled()) {
              pet.getEntityPet().onInteract(p);
              return;
          }
      }
  }
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
@Override
public int howMuchSpaceForItemAsync(WrappedDirection insertDirection, ItemStack insertion) {
	if (!cachedChunk.isLoaded()) {
		return 0;
	}
	if (isInvLocked(cachedInvHolder)) {
		return 0;
	}
	int freeSpace = 0;
	for (int i = 0; i < cachedInv.getSize(); i++) {
		ItemStack is = cachedInv.getItem(i);
		if (is == null || is.getType() == Material.AIR) {
			freeSpace += insertion.getMaxStackSize();
		} else if (is.isSimilar(insertion) && is.getAmount() < is.getMaxStackSize()) {
			freeSpace += is.getMaxStackSize() - is.getAmount();
		}
	}
	return freeSpace;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
@Override
public boolean hasInputItems( ItemStack itemStack, int amount ) {
    int count = 0;
    int i = 0;
    for ( ItemStack craftingSlot : craftingSlots ) {
        if ( i != 0 ) {
            if ( craftingSlot != null && craftingSlot.getType() != Material.AIR ) {
                if ( craftingSlot.isSimilar( itemStack ) ) {
                    count++;
                }
            }
        }
        i++;
    }
    return count == amount;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
public boolean containsAtLeast(ItemStack item, int amount) {
    if (item == null) {
        return false;
    }
    if (amount <= 0) {
        return true;
    }
    for (ItemStack i : getContents()) {
        if (item.isSimilar(i) && (amount -= i.getAmount()) <= 0) {
            return true;
        }
    }
    return false;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
private int first(ItemStack item, boolean withAmount) {
    if (item == null) {
        return -1;
    }
    ItemStack[] inventory = getContents();
    for (int i = 0; i < inventory.length; i++) {
        if (inventory[i] == null) continue;

        if (withAmount ? item.equals(inventory[i]) : item.isSimilar(inventory[i])) {
            return i;
        }
    }
    return -1;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
private int firstPartial(ItemStack item) {
    if (item == null) {
        return -1;
    }
    ItemStack[] inventory = getContents();
    ItemStack filteredItem = CraftItemStack.asCraftCopy(item);
    for (int i = 0; i < inventory.length; i++) {
        ItemStack cItem = inventory[i];
        if (cItem != null && cItem.getAmount() < cItem.getMaxStackSize() && cItem.isSimilar(filteredItem)) {
            return i;
        }
    }
    return -1;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
public static boolean hasItem(Player p, ItemStack item) {
    for (int k = 0; k < p.getInventory().getSize(); k++) {
        ItemStack i = p.getInventory().getItem(k);
        if (i != null && i.isSimilar(item)) {
            return true;
        }
    }
    return false;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
public Skill getSkillBySelector(ItemStack item) {
    Skill result = null;
    for (Skill s : skills) {
        ItemStack skill = s.getSelector();
        if (skill.isSimilar(item)) {
            result = s;
        }
    }
    return result;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
/**
 * Return the quantity of items stackable with the given item that
 * the player was in posession of prior to the transfer event. This
 * includes any items being carried on the cursor.
 */
public int getPriorQuantity(ItemStack type) {
    int quantity = 0;
    for(ItemStack stack : this.player.getInventory().contents()) {
        if(stack != null && stack.isSimilar(type)) {
            quantity += stack.getAmount();
        }
    }
    if(this.cursorItems != null && this.cursorItems.isSimilar(type)) {
        quantity += this.cursorItems.getAmount();
    }
    return quantity;
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
private void processClickEvent(InventoryClickEvent event) {
    if (event.getAction() == InventoryAction.COLLECT_TO_CURSOR) {
        ItemStack cursorItem = event.getCursor();
        Inventory topInv = event.getView().getTopInventory();
        for (int i = 0; i < topInv.getSize(); i++) {
            ItemStack item = topInv.getItem(i);
            if (item != null && item.isSimilar(cursorItem)) {
                event.setCancelled(true);
                break;
            }
        }
    }
}
 

import org.bukkit.inventory.ItemStack; //导入方法依赖的package包/类
@Override
public ItemStack extractItem(WrappedDirection extractDirection, int extractAmount, List<ItemData> filterItems,
		FilteringMode filteringMode) {
	if (!cachedChunk.isLoaded()) {
		return null;
	}
	if (isInvLocked(cachedInvHolder)) {
		return null;
	}
	ItemStack takenIs = null;
	for (int i = 0; i < cachedInv.getSize(); i++) {
		if (cachedInv.getItem(i) != null) {
			int amountBefore = takenIs != null ? takenIs.getAmount() : 0;
			if (takenIs == null) {
				if (new ItemData(cachedInv.getItem(i)).checkFilter(filterItems, filteringMode)) {
					takenIs = cachedInv.getItem(i).clone();
					takenIs.setAmount(Math.min(extractAmount, takenIs.getAmount()));
				} else {
					continue;
				}
			} else if (takenIs.isSimilar(cachedInv.getItem(i))) {
				takenIs.setAmount(Math.min(extractAmount, amountBefore + cachedInv.getItem(i).getAmount()));
			}
			ItemStack invItem = cachedInv.getItem(i);
			cachedInv.setItem(i, InventoryUtils.changeAmount(invItem, -(takenIs.getAmount() - amountBefore)));
		}
	}
	if (takenIs != null) {
		block.getState().update();
	}
	return takenIs;
}