Java ItemStack.EMPTY属性代码示例

@Override
public ItemStack getCraftingResult(InventoryCrafting inv) {
    Optional<RandoresItemData> itemDataOptional = extractData(inv);
    if (itemDataOptional.isPresent()) {
        RandoresItemData data = itemDataOptional.get();
        if (RandoresWorldData.contains(data)) {
            MaterialDefinition definition = RandoresWorldData.get(data);
            Component component = this.type.from(definition);
            ItemStack res = definition.createStack(component);
            res.setCount(this.quantity);
            return res;
        }
    }

    return ItemStack.EMPTY;
}
 

@Nonnull
@Override
public ItemStack extractItem(int slot, int amount, boolean simulate) {
    if (storage.getStackInSlot(slot).isEmpty() || amount == 0) return ItemStack.EMPTY;
    ItemStack existing = blackHoleUnitBlock.getItemStack(storage.getStackInSlot(slot)).copy();
    if (existing.isEmpty()) return ItemStack.EMPTY;
    int visualAmount = blackHoleUnitBlock.getAmount(storage.getStackInSlot(slot)) + output.getStackInSlot(slot).getCount();
    if (visualAmount <= amount) {
        if (!simulate) {
            blackHoleUnitBlock.setAmount(storage.getStackInSlot(slot), 0);
            output.setStackInSlot(slot, ItemStack.EMPTY);
        }
        return ItemHandlerHelper.copyStackWithSize(existing, visualAmount);
    } else {
        if (!simulate) {
            blackHoleUnitBlock.setAmount(storage.getStackInSlot(slot), Math.max(0, blackHoleUnitBlock.getAmount(storage.getStackInSlot(slot)) - amount));
            output.setStackInSlot(slot, ItemHandlerHelper.copyStackWithSize(existing, Math.min(64, visualAmount - amount)));
        }
        return ItemHandlerHelper.copyStackWithSize(existing, amount);
    }
}
 

@Override
public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) {
	ItemStack itemstack = ItemStack.EMPTY;
	Slot slot = this.inventorySlots.get(index);

	if (slot != null && slot.getHasStack()) {
		ItemStack itemstack1 = slot.getStack();
		itemstack = itemstack1.copy();

		if (index < 2) {
			if (!this.mergeItemStack(itemstack1, 2, this.inventorySlots.size(), true)) {
				return ItemStack.EMPTY;
			}
		} else if (!this.mergeItemStack(itemstack1, 0, 1, false)) {
			return ItemStack.EMPTY;
		}

		if (itemstack1.isEmpty()) {
			slot.putStack(ItemStack.EMPTY);
		} else {
			slot.onSlotChanged();
		}
	}

	return itemstack;
}
 

@Override
public ItemStack getCraftingResult(InventoryCrafting inv) {
	ItemStack out = new ItemStack(ModItems.sword);

	if (adornmentMat == null) {
		adornmentMat = ModMaterials.ADORNMENT_NULL;
	}

	if (bladeMat == null || crossguardMat == null || handleMat == null || adornmentMat == null) {
		return ItemStack.EMPTY;
	}

	NBTTagCompound tag = new NBTTagCompound();
	tag.setString(IBladeTool.BLADE_TAG, bladeMat.getName());
	tag.setString(ICrossguardTool.CROSSGUARD_TAG, crossguardMat.getName());
	tag.setString(IHandleTool.HANDLE_TAG, handleMat.getName());
	tag.setString(IAdornedTool.ADORNMENT_TAG, adornmentMat.getName());
	out.setTagCompound(tag);

	return out;
}
 

/**
 * Callback for when the crafting matrix is changed.
 */
@Override
public void onCraftMatrixChanged(IInventory inventoryIn) {
	ItemStack stack = ItemStack.EMPTY;
	List<IRecipe> recipes = TF2CraftingManager.INSTANCE.getRecipeList();
	if (currentRecipe >= 0 && currentRecipe < recipes.size()
			&& recipes.get(currentRecipe).matches(this.craftMatrix, world))
		stack = getReplacement(player, recipes.get(currentRecipe).getCraftingResult(this.craftMatrix));
	// ?TF2CraftingManager.INSTANCE.getRecipeList().get(currentRecipe)TF2CraftingManager.INSTANCE.findMatchingRecipe(this.craftMatrix,
	// this.world);
	else
		stack = getReplacement(player, TF2CraftingManager.INSTANCE.findMatchingRecipe(this.craftMatrix, this.world));
	this.craftResult.setInventorySlotContents(0, stack);
}
 

@Override
public ItemStack transferStackInSlot(EntityPlayer player, int sourceSlotIndex) {
	Slot sourceSlot = inventorySlots.get(sourceSlotIndex);
	if (sourceSlot == null || !sourceSlot.getHasStack())
		return ItemStack.EMPTY;
	ItemStack sourceStack = sourceSlot.getStack();
	ItemStack copyOfSourceStack = sourceStack.copy();

	if (sourceSlotIndex >= VANILLA_FIRST_SLOT_INDEX && sourceSlotIndex < VANILLA_FIRST_SLOT_INDEX + VANILLA_SLOT_COUNT) {
		if (!mergeItemStack(sourceStack, TE_INVENTORY_FIRST_SLOT_INDEX, TE_INVENTORY_FIRST_SLOT_INDEX + TE_INVENTORY_SLOT_COUNT, false)) {
			return ItemStack.EMPTY;
		}
	} else if (sourceSlotIndex >= TE_INVENTORY_FIRST_SLOT_INDEX && sourceSlotIndex < TE_INVENTORY_FIRST_SLOT_INDEX + TE_INVENTORY_SLOT_COUNT) {
		if (!mergeItemStack(sourceStack, VANILLA_FIRST_SLOT_INDEX, VANILLA_FIRST_SLOT_INDEX + VANILLA_SLOT_COUNT, false)) {
			return ItemStack.EMPTY;
		}
	} else {
		System.err.print("Invalid slotIndex:" + sourceSlotIndex);
		return ItemStack.EMPTY;
	}

	if (sourceStack.getCount() == 0) {
		sourceSlot.putStack(ItemStack.EMPTY);
	} else {
		sourceSlot.onSlotChanged();
	}

	sourceSlot.onTake(player, sourceStack);
	return copyOfSourceStack;
}
 

@Override
public void drawPost(int x, int y, int mouseX, int mouseY, GuiScreen notebook)
{
	// New matrix!
	GlStateManager.pushMatrix();
	GlStateManager.pushAttrib();

	// Adjust the x and y values to fit the tooltips properly
	x += 22;
	y += 3;

	// Render the tooltips for the recipe matrix
	for (int inputX = 0; inputX < 3; inputX++)
	{
		for (int inputY = 0; inputY < 3; inputY++)
		{
			if (recipeIn[inputY][inputX] != ItemStack.EMPTY)
			{
				// Render the tooltip if the mouse is over the item
				drawItemstackTooltip(recipeIn[inputY][inputX], x + (inputX * 25), y + (inputY * 25), mouseX, mouseY,
						notebook);
			}
		}
	}

	// Draw the tooltip for the output item
	drawItemstackTooltip(recipeOut, x + 113, y + 25, mouseX, mouseY, notebook);

	// Go back to the main render matrix
	GlStateManager.popAttrib();
	GlStateManager.popMatrix();
}
 

@SubscribeEvent
public void updateEntity(LivingEvent.LivingUpdateEvent event){
    if(event.getEntity() instanceof EntityPlayer && event.getEntity().getAir() <= 300 - Config.ARMOR_TICKS_PER_LANOLIN){
        // The entity is a player and is not at full air
        if(event.getEntity().isInsideOfMaterial(Material.WATER)){
            for(int i = 0; i < 4; i++){
                ItemStack armorPiece = ((EntityPlayer) event.getEntity()).inventory.armorInventory.get(i);
                if(armorPiece != ItemStack.EMPTY){
                    NBTTagCompound tags = armorPiece.getTagCompound();
                    if(tags != null && tags.hasKey("lanolin")){
                        // Found armor with lanolin. Reset air and remove a piece of lanolin.
                        event.getEntity().setAir(300);
                        if(tags.getInteger("lanolin") == 1){
                            // No more lanolin on this item, remove the tag
                            tags.removeTag("lanolin");
                        }
                        else{
                            tags.setInteger("lanolin", tags.getInteger("lanolin")-1);
                        }
                        armorPiece.setTagCompound(tags);
                        ((EntityPlayer) event.getEntity()).inventory.armorInventory.set(i, armorPiece);
                        break;
                    }
                }
            }
        }
    }
}
 

@Override
public ItemStack getStackInSlot(int index) {
	if (index < 0 || index >= this.getSizeInventory()) {
		return ItemStack.EMPTY;
	}

	return inventory.get(index);
}
 

@Nonnull
@Override
public ItemStack extractItem(int slot, int amount, boolean simulate)
{
    if (slotChecksEnabled && type.isFuelSlot(slot))
    {
        Item item = getStackInSlot(slot).getItem();
        if (item != Items.WATER_BUCKET && item != Items.BUCKET)
            return ItemStack.EMPTY;
    }

    return super.extractItem(slot, amount, simulate);
}
 

public static ItemStack getFirstItem(IInventory inventory, Predicate<ItemStack> pred) {
	
		for (int i = 0; i<inventory.getSizeInventory(); i++) {
			ItemStack stack=inventory.getStackInSlot(i);
			if (!stack.isEmpty() && pred.apply(stack))
				return stack;
		}
		return ItemStack.EMPTY;
}
 

@Override
public void readFromNBT(NBTTagCompound compound)
{
	super.readFromNBT(compound);
	if (compound.hasKey("item"))
	{
		stack = new ItemStack(compound.getCompoundTag("item"));
	} else
	{
		stack = ItemStack.EMPTY;
	}
}
 

@Override
public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) {
    ItemStack itemstack = ItemStack.EMPTY;
    Slot slot = this.inventorySlots.get(index);

    if (slot != null && slot.getHasStack()) {
        ItemStack itemstack1 = slot.getStack();
        itemstack = itemstack1.copy();

        if(index >= 0 && index < 36) {
            if(!itemstack1.isEmpty() && itemstack1.getItem() instanceof ItemBlueprint) {
                Slot sb = this.inventorySlots.get(this.slotBlueprint.slotNumber);
                if(!sb.getHasStack()) {
                    if(!this.mergeItemStack(itemstack1, sb.slotNumber, sb.slotNumber + 1, false)) {
                        return ItemStack.EMPTY;
                    }
                }
            }
        }

        if (index >= 0 && index < 27) {
            if (!this.mergeItemStack(itemstack1, 27, 36, false)) {
                return ItemStack.EMPTY;
            }
        } else if (index >= 27 && index < 36) {
            if (!this.mergeItemStack(itemstack1, 0, 27, false)) {
                return ItemStack.EMPTY;
            }
        } else if (!this.mergeItemStack(itemstack1, 0, 36, false)) {
            return ItemStack.EMPTY;
        }

        if (itemstack1.getCount() == 0) {
            slot.putStack(ItemStack.EMPTY);
        } else {
            slot.onSlotChanged();
        }

        if (itemstack1.getCount() == itemstack.getCount()) {
            return ItemStack.EMPTY;
        }

        slot.onTake(playerIn, itemstack1);
    }

    return itemstack;
}
 

@Override
public ItemStack getItemStackFromSlot(EntityEquipmentSlot slotIn) {
	return ItemStack.EMPTY;
}
 

default ItemStack getJEIIcon(){
    return ItemStack.EMPTY;
}