public static int getIndex(ItemStack output) { for (int i = 0; i < outputList.size(); i++) { if (ItemHelper.itemsIdentical(output, outputList.get(i))) { return i; } } // Default to first if no match found. return 0; }
public static int getIndex(ItemStack output, boolean sedimentary) { if (sedimentary) { for (int i = 0; i < outputListSedimentary.size(); i++) { if (ItemHelper.itemsIdentical(output, outputListSedimentary.get(i))) { return i; } } } else { for (int i = 0; i < outputListIgneous.size(); i++) { if (ItemHelper.itemsIdentical(output, outputListIgneous.get(i))) { return i; } } } // Default to first if no match found. return 0; }
private boolean validStack(ItemStack stack, int slot) { if (isItemStackRecipe) { return ItemHelper.itemsIdentical(stack, craftStacks[slot]); } return craftIngredients[slot].apply(stack); }
@Override public boolean isItemValid(ItemStack stack) { return myTile.hasPreferredStack(stack) && !ItemHelper.itemsIdentical(stack, myTile.getPreferredStack(stack)); }
@Override public boolean isItemValidForSlot(int slot, ItemStack stack) { return slot != 0 || LexiconManager.validOre(stack) && hasPreferredStack(stack) && !ItemHelper.itemsIdentical(stack, getPreferredStack(stack)); }
public void onSelectionChanged(String oreName) { oreList = OreDictionaryArbiter.getOres(oreName); if (LexiconManager.hasPreferredStack(player, oreName)) { ItemStack ore = LexiconManager.getPreferredStack(player, oreName); lexiconInv.setInventorySlotContents(0, ore); for (int i = 0; i < oreList.size(); i++) { if (ItemHelper.itemsIdentical(oreList.get(i), ore)) { oreSelection = i; break; } } } PacketTFBase.sendLexiconStudySelectPacketToServer(ContainerLexiconStudy.SELECT_ORE, (oreName)); }
public void setItem(ItemStack stack) { ItemStack curInstance = storedInstance.copy(); this.storedInstance = ItemHelper.cloneStack(stack, 1); this.storedStack = stack; if (tile.world != null) { tile.updateTrackers(); if (!ItemHelper.itemsIdentical(curInstance, storedInstance)) { tile.markChunkDirty(); } } }
public static int getNumItems(IItemHandler inv, int side, ItemStack insertingItem, int cap) { //if (inv instanceof IDeepStorageUnit) { // ItemStack storedItemType = ((IDeepStorageUnit) inv).getStoredItemType(); // if (ItemHelper.itemsIdentical(storedItemType, insertingItem)) { // return storedItemType.stackSize; // } else { // return 0; // } //} int storedNo = 0; for (int slot = 0; slot < inv.getSlots(); slot++) { ItemStack stackInSlot = inv.getStackInSlot(slot); if (ItemHelper.itemsIdentical(stackInSlot, insertingItem)) { storedNo += stackInSlot.getCount(); if (storedNo >= cap) { return storedNo; } } } return storedNo; }
protected void catchFish() { ItemStack fish = FisherManager.getFish(); for (int j = 1; j < 5; j++) { if (inventory[j].isEmpty()) { inventory[j] = ItemHelper.cloneStack(fish); break; } else if (inventory[j].getCount() < inventory[j].getMaxStackSize() && ItemHelper.itemsIdentical(inventory[j], fish)) { inventory[j].grow(1); break; } } }
if (ItemHelper.itemsIdentical(craftStacks[i], myTile.inventory[j]) && myTile.inventory[j].getCount() - craftCount[j] > 0) { craftCount[j]++; craftSlots[i] = j + 1;
lexiconInv.setInventorySlotContents(0, ore); for (int i = 0; i < oreList.size(); i++) { if (ItemHelper.itemsIdentical(oreList.get(i), ore)) { oreSelection = i; break;
@Nonnull @Override public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) { if (stack.isEmpty()) { return stack; } int toInsert = stack.getCount(); if (getSpace() < toInsert) { toInsert = getSpace(); } ItemStack ret = ItemHelper.cloneStack(stack, stack.getCount() - toInsert); if (storedInstance.isEmpty()) { if (!simulate) { setItem(ItemHelper.cloneStack(stack, toInsert)); } return ret; } if (!ItemHelper.itemsIdentical(stack, storedInstance)) { return stack; } if (!simulate) { storedStack.grow(toInsert); tile.updateTrackers(); tile.markChunkDirty(); } return ret; }
private void transferHandler() { if (hasFluidHandler) { if (inventory[2].isEmpty()) { inventory[2] = ItemHelper.cloneStack(inventory[1], 1); inventory[1] = ItemStack.EMPTY; hasFluidHandler = false; } else { if (ItemHelper.itemsIdentical(inventory[1], inventory[2]) && inventory[1].getMaxStackSize() > 1 && inventory[2].getCount() + 1 <= inventory[2].getMaxStackSize()) { inventory[2].grow(1); inventory[1] = ItemStack.EMPTY; hasFluidHandler = false; } } } if (!hasFluidHandler && FluidHelper.isFluidHandler(inventory[0])) { inventory[1] = ItemHelper.cloneStack(inventory[0], 1); inventory[0].shrink(1); if (inventory[0].getCount() <= 0) { inventory[0] = ItemStack.EMPTY; } hasFluidHandler = true; } }
private void transferRepairItem() { if (hasRepairItem) { if (inventory[2].isEmpty()) { inventory[2] = ItemHelper.cloneStack(inventory[1], 1); inventory[1] = ItemStack.EMPTY; hasRepairItem = false; } else { if (ItemHelper.itemsIdentical(inventory[1], inventory[2]) && inventory[1].getMaxStackSize() > 1 && inventory[2].getCount() + 1 <= inventory[2].getMaxStackSize()) { inventory[2].grow(1); inventory[1] = ItemStack.EMPTY; hasRepairItem = false; } } } if (!hasRepairItem && inventory[0].isItemStackDamageable() && augmentRepair) { inventory[1] = ItemHelper.cloneStack(inventory[0], 1); inventory[0].shrink(1); if (inventory[0].getCount() <= 0) { inventory[0] = ItemStack.EMPTY; } hasRepairItem = true; } }
private void transferHandler() { if (hasEnergyHandler) { if (inventory[2].isEmpty()) { inventory[2] = ItemHelper.cloneStack(inventory[1], 1); inventory[1] = ItemStack.EMPTY; handler = null; hasEnergyHandler = false; } else { if (ItemHelper.itemsIdentical(inventory[1], inventory[2]) && inventory[1].getMaxStackSize() > 1 && inventory[2].getCount() + 1 <= inventory[2].getMaxStackSize()) { inventory[2].grow(1); inventory[1] = ItemStack.EMPTY; handler = null; hasEnergyHandler = false; } } } if (!hasEnergyHandler && EnergyHelper.isEnergyHandler(inventory[0]) && !augmentRepair) { inventory[1] = ItemHelper.cloneStack(inventory[0], 1); inventory[0].shrink(1); if (inventory[0].getCount() <= 0) { inventory[0] = ItemStack.EMPTY; } handler = inventory[1].getCapability(CapabilityEnergy.ENERGY, null); hasEnergyHandler = true; } }
private void transferContainerItem() { if (hasContainerItem) { if (inventory[2].isEmpty()) { inventory[2] = ItemHelper.cloneStack(inventory[1], 1); inventory[1] = ItemStack.EMPTY; containerItem = null; hasContainerItem = false; } else { if (ItemHelper.itemsIdentical(inventory[1], inventory[2]) && inventory[1].getMaxStackSize() > 1 && inventory[2].getCount() + 1 <= inventory[2].getMaxStackSize()) { inventory[2].grow(1); inventory[1] = ItemStack.EMPTY; containerItem = null; hasContainerItem = false; } } } if (!hasContainerItem && EnergyHelper.isEnergyContainerItem(inventory[0]) && !augmentRepair) { inventory[1] = ItemHelper.cloneStack(inventory[0], 1); inventory[0].shrink(1); if (inventory[0].getCount() <= 0) { inventory[0] = ItemStack.EMPTY; } containerItem = (IEnergyContainerItem) inventory[1].getItem(); hasContainerItem = true; } }
@SubscribeEvent (priority = EventPriority.HIGHEST) public void handleEntityItemPickupEvent(EntityItemPickupEvent event) { EntityItem item = event.getItem(); ItemStack stack = item.getItem(); if (stack.isEmpty() || !LexiconManager.validOre(stack)) { return; } EntityPlayer player = event.getEntityPlayer(); NBTTagCompound tag = player.getEntityData(); // Cannot be null if (player.world.getTotalWorldTime() - tag.getLong(TFProps.LEXICON_TIMER) > 20) { return; } ItemStack lexiconStack = LexiconManager.getPreferredStack(player, stack); if (ItemHelper.itemsIdentical(stack, lexiconStack)) { return; } item.setItem(lexiconStack.copy()); event.setCanceled(true); item.onCollideWithPlayer(player); }
boolean match = true; for (int i = 1; i < target.recipeItems.size(); i++) { match &= target.recipeItems.get(i).getMatchingStacks().length > 0 && ItemHelper.itemsIdentical(target.recipeItems.get(0).getMatchingStacks()[0], target.recipeItems.get(i).getMatchingStacks()[0]); boolean match = true; for (int i = 1; i < target.recipeItems.size(); i++) { match &= target.recipeItems.get(i).getMatchingStacks().length > 0 && ItemHelper.itemsIdentical(target.recipeItems.get(0).getMatchingStacks()[0], target.recipeItems.get(i).getMatchingStacks()[0]);
if (ItemHelper.itemsIdentical(insertingItem, travelingItems.getItems().next())) { insertingItem.grow(travelingItems.getItems().next().getCount()); return simulateInsertItemStackIntoInventory(itemHandler, insertingItem, side ^ 1, maxStock); int s = 0; for (ItemStack travelingItem : travelingItems.getItems()) { if (!ItemHelper.itemsIdentical(insertingItem, travelingItem)) { s = -1; break; continue; if (!InventoryHelper.insertStackIntoInventory(simulatedInv, itemEntry.toItemStack(iterator.value()), false).isEmpty() && ItemHelper.itemsIdentical(insertingItem, itemEntry.toItemStack(iterator.value()))) { return insertingItem;
@Override protected void processFinish() { IRecipe recipe = craftResult.getRecipeUsed(); if (recipe == null || !checkIngredients()) { processOff(); return; } craftRecipe.evaluate(); ItemStack output = recipe.getCraftingResult(craftMatrix); NonNullList<ItemStack> remainingItems = recipe.getRemainingItems(craftMatrix); for (int i = 0; i < remainingItems.size(); i++) { ItemStack remaining = remainingItems.get(i); if (!remaining.isEmpty() && !craftRecipe.isFalseBucket(i)) { for (int j = 0; j < SLOT_OUTPUT; j++) { if (inventory[j].isEmpty()) { inventory[j] = remaining; break; } else if (remaining.getMaxStackSize() > 1 && ItemHelper.itemsIdentical(inventory[j], remaining) && inventory[j].getCount() < inventory[j].getMaxStackSize()) { inventory[j].grow(1); break; } } } } if (inventory[SLOT_OUTPUT].isEmpty()) { inventory[SLOT_OUTPUT] = ItemHelper.cloneStack(output); } else { inventory[SLOT_OUTPUT].grow(output.getCount()); } }