Excuse the vague title, I couldn't really describe it short and sweet

Right, basically I'm trying to make an item that can recieve power, for now I'm just adding the power directly every tick here: https://github.com/MistaOmega/Opes/blob/master/src/main/java/mistaomega/opes/items/StarlightInfusedNetherStar.java#L68-L75

 

Problem is, when I remove the item and get a new one, the power remains the same, so the basic question is, is there a way to only handle instances of items rather than every item from within this class, so that if I was to replace this item, the power would be different and not the same as when I removed it.

 

Thank you for any help ❤️

 

AttachCapabilitiesEvent to attach the capability to the itemstacks

Override Item#initCapabilities. In there, return a new ICapabilityProvider, essentially a wrapper for the getCapability method. Then, perform ItemStack#getCapability to query the ICapabilityProvider from the Item class.

Here's an example from my code.

 

@Override
	public ICapabilityProvider initCapabilities(ItemStack stack, CompoundNBT nbt) {
		return new ICapabilityProvider() {
			
			protected IEnergyStorage energy = new IEnergyStorage() {

				@Override
				public int receiveEnergy(int maxReceive, boolean simulate) {

					if (getMaxPower() < maxReceive + getCurrentPower(stack)) {
						maxReceive = getMaxPower() - getCurrentPower(stack);
					}

					if (simulate == false) {
						setCurrentPower(stack, getCurrentPower(stack) + maxReceive);
					}

					return maxReceive;
				}

				@Override
				public int getMaxEnergyStored() {
					return getMaxPower();
				}

				@Override
				public int getEnergyStored() {
					return getCurrentPower(stack);
				}

				@Override
				public int extractEnergy(int maxExtract, boolean simulate) {
					return 0;
				}

				@Override
				public boolean canReceive() {
					return true;
				}

				@Override
				public boolean canExtract() {
					return false;
				}
			};
			protected LazyOptional<IEnergyStorage> energyHandler = LazyOptional.of(() -> energy);
			
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				return this.getCapability(cap);
			}

			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap) {
				if (cap == CapabilityEnergy.ENERGY) {
					return energyHandler.cast();
				}

				return  LazyOptional.empty();
			}
		};
	}

 

57 minutes ago, Haydenman2 said:

return LazyOptional.empty();

Don't do this. Return super if the capability isn't the one you care about, you never know who else might attach a capability to a stack.

Scratch that, I was thinking about how things work for TileEntities.

Edited June 21, 20205 yr by Draco18s

Howdy 

You need to store the information inside an ItemStack.  A unique ItemStack is created every time your Item is spawned:  ItemStack is the class used when an Item is actually "created" - in addition to the Item type, it also stores the item count (eg a stack of 46 planks), "damage" (eg pickaxe "wear-and-tear" indicator), and several other pieces of information

 

The easiest way to do that is NBT, for  a working example see here

https://github.com/TheGreyGhost/MinecraftByExample/tree/master/src/main/java/minecraftbyexample/mbe11_item_variants

or here

https://github.com/TheGreyGhost/MinecraftByExample/tree/master/src/main/java/minecraftbyexample/mbe12_item_nbt_animate

 

Like the other folks said, you can use a Capability but that is considerably more complicated / difficult to understand and isn't necessary unless you want other mods to be able to read/control the power of your item without knowing what kind of item it is.

 

-TGG

 

Makes sense, thank you all for the help! 😊

(redacted)

Edited June 21, 20205 yr by MistaOmega
Solved the problem so comment is unneccesary