Java Code Examples for net.minecraft.item.Item#getItemById()

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

/**
 * Relocates a stack nbt from the world referential to the registry
 * referential.
 */
public void stackToRegistry(NBTTagCompound nbt) {
	Item item = Item.getItemById(nbt.getShort("id"));
	nbt.setShort("id", (short) getIdForItem(item));
}
 

public int itemIdToRegistry(int id) {
	Item item = Item.getItemById(id);

	return getIdForItem(item);
}
 

@Override
public void storeItem(BaseItem item) throws BlockBagException {
    final int id = item.getType();
    final int damage = item.getData();
    int amount = (item instanceof BaseItemStack) ? ((BaseItemStack) item).getAmount() : 1;
    assert(amount <= 64);
    boolean usesDamageValue = ItemType.usesDamageValue(id);

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

    loadInventory();

    int freeSlot = -1;

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

        if (forgeItem == null) {
            // Delay using up a free slot until we know there are no stacks
            // of this item to merge into

            if (freeSlot == -1) {
                freeSlot = slot;
            }
            continue;
        }

        int itemId = Item.getIdFromItem(forgeItem.getItem());
        if (itemId != id) {
            // Type id doesn't fit
            continue;
        }

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

        int currentAmount = forgeItem.getCount();
        if (currentAmount < 0) {
            // Unlimited
            return;
        }
        if (currentAmount >= 64) {
            // Full stack
            continue;
        }

        changed = true;

        int spaceLeft = 64 - currentAmount;
        if (spaceLeft >= amount) {
            forgeItem.setCount(forgeItem.getCount() + amount);
            return;
        }

        forgeItem.setCount(64);
        amount -= spaceLeft;
    }

    if (freeSlot > -1) {
        changed = true;
        items[freeSlot] = new ItemStack(Item.getItemById(id), amount);
        return;
    }

    throw new OutOfSpaceException(id);
}
 

@Override
public void storeItem(BaseItem item) throws BlockBagException {
    final int id = item.getType();
    final int damage = item.getData();
    int amount = (item instanceof BaseItemStack) ? ((BaseItemStack) item).getAmount() : 1;
    assert(amount <= 64);
    boolean usesDamageValue = ItemType.usesDamageValue(id);

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

    loadInventory();

    int freeSlot = -1;

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

        if (forgeItem == null) {
            // Delay using up a free slot until we know there are no stacks
            // of this item to merge into

            if (freeSlot == -1) {
                freeSlot = slot;
            }
            continue;
        }

        int itemId = Item.getIdFromItem(forgeItem.getItem());
        if (itemId != id) {
            // Type id doesn't fit
            continue;
        }

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

        int currentAmount = forgeItem.stackSize;
        if (currentAmount < 0) {
            // Unlimited
            return;
        }
        if (currentAmount >= 64) {
            // Full stack
            continue;
        }

        changed = true;

        int spaceLeft = 64 - currentAmount;
        if (spaceLeft >= amount) {
            forgeItem.stackSize += amount;
            return;
        }

        forgeItem.stackSize = (64);
        amount -= spaceLeft;
    }

    if (freeSlot > -1) {
        changed = true;
        items[freeSlot] = new ItemStack(Item.getItemById(id), amount);
        return;
    }

    throw new OutOfSpaceException(id);
}
 

@Override
protected Item getDropItem() {
  return Item.getItemById(-1);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

@Override
public void storeItem(BaseItem item) throws BlockBagException {
    final int id = item.getType();
    final int damage = item.getData();
    int amount = (item instanceof BaseItemStack) ? ((BaseItemStack) item).getAmount() : 1;
    assert(amount <= 64);
    boolean usesDamageValue = ItemType.usesDamageValue(id);

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

    loadInventory();

    int freeSlot = -1;

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

        if (forgeItem == null) {
            // Delay using up a free slot until we know there are no stacks
            // of this item to merge into

            if (freeSlot == -1) {
                freeSlot = slot;
            }
            continue;
        }

        int itemId = Item.getIdFromItem(forgeItem.getItem());
        if (itemId != id) {
            // Type id doesn't fit
            continue;
        }

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

        int currentAmount = forgeItem.stackSize;
        if (currentAmount < 0) {
            // Unlimited
            return;
        }
        if (currentAmount >= 64) {
            // Full stack
            continue;
        }

        changed = true;

        int spaceLeft = 64 - currentAmount;
        if (spaceLeft >= amount) {
            forgeItem.stackSize += amount;
            return;
        }

        forgeItem.stackSize = (64);
        amount -= spaceLeft;
    }

    if (freeSlot > -1) {
        changed = true;
        items[freeSlot] = new ItemStack(Item.getItemById(id), amount);
        return;
    }

    throw new OutOfSpaceException(id);
}
 

@Deprecated
// A bad method for bad magic.
public static Item getItem(int id) {
    return Item.getItemById(id);
}
 

public static Item getItem(Material material) {
    // TODO: Don't use ID
    Item item = Item.getItemById(material.getId());
    return item;
}
 

public WeightedRandomLoot(Block block, int i) {
	this(Item.getItemById(Block.getIdFromBlock(block)), i);
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

public static WrapperItem getItemById(int var0) {
    return new WrapperItem(Item.getItemById(var0));
}
 

/**
 * Returns the item ID for the item the mob drops on death.
 */
@Override
protected Item getDropItem()
{
	return Item.getItemById(0);
}
 

public static ItemStack getSearchedStack(ItemStack helmetStack){
    if(helmetStack == null || !NBTUtil.hasTag(helmetStack, "SearchStack")) return null;
    NBTTagCompound tag = NBTUtil.getCompoundTag(helmetStack, "SearchStack");
    if(tag.getInteger("itemID") == -1) return null;
    return new ItemStack(Item.getItemById(tag.getInteger("itemID")), 1, tag.getInteger("itemDamage"));
}