public class PowerArmor extends ArmorItem implements IEnergyStorage{
	protected int energy;
    protected int capacity;
    protected int maxReceive;
    protected int maxExtract;
	    
	public PowerArmor(IArmorMaterial materialIn, EquipmentSlotType slot, Properties builder) {
		super(materialIn, slot, builder);
		this.capacity = 10000;
        this.maxReceive = 1000;
        this.maxExtract = 1000;
        this.energy = Math.max(0 , Math.min(capacity, energy));
	}
	
    @Override
    public int receiveEnergy(int maxReceive, boolean simulate)
    {
        if (!canReceive())
            return 0;

        int energyReceived = Math.min(capacity - energy, Math.min(this.maxReceive, maxReceive));
        if (!simulate)
            energy += energyReceived;
        return energyReceived;
    }

    @Override
    public int extractEnergy(int maxExtract, boolean simulate)
    {
        if (!canExtract())
            return 0;

        int energyExtracted = Math.min(energy, Math.min(this.maxExtract, maxExtract));
        if (!simulate)
            energy -= energyExtracted;
        return energyExtracted;
    }

    @Override
    public int getEnergyStored()
    {
        return energy;
    }

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

    @Override
    public boolean canExtract()
    {
        return this.maxExtract > 0;
    }

    @Override
    public boolean canReceive()
    {
        return this.maxReceive > 0;
    }

}

This is my code. I've heard that I need to use initCapabilities. How would I do that?

Don't implement a capability interface on your item, override initCapabilities and return your capability instance there.

What do you mean by that?

Like this?
 

@Override
    public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return new ICapabilityProvider() {
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				return (LazyOptional<T>) LazyOptional.of(() -> IEnergyStorage.class);
			}
        };
    }

 

You shouldn't recreate LazyOptional instances every time they're needed.

But essentially yes.

public class PowerArmor extends ArmorItem{
	protected int energy;
    protected int capacity;
    protected int maxReceive;
    protected int maxExtract;
	public ICapabilityProvider capability;
    
	public PowerArmor(IArmorMaterial materialIn, EquipmentSlotType slot, Properties builder) {
		super(materialIn, slot, builder);
		this.capacity = 10000;
        this.maxReceive = 1000;
        this.maxExtract = 1000;
        this.energy = Math.max(0 , Math.min(capacity, energy));
        this.capability = new ICapabilityProvider() {
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				return (LazyOptional<T>) LazyOptional.of(() -> IEnergyStorage.class);
			}
        };
	}
	
	@Override
    public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return this.capability;
    }
}

Is this good?

Ok I tested it and get this:

The game crashed whilst ticking block entity
Error: java.lang.ClassCastException: java.lang.Class cannot be cast to net.minecraftforge.energy.IEnergyStorage

You're also still recreating the LazyOptional every time its gotten.

Compare:

https://github.com/Draco18s/ReasonableRealism/blob/1.14.4/src/main/java/com/draco18s/harderores/entity/AxelTileEntity.java#L28

protected int energy;
protected int capacity;
protected int maxReceive;
protected int maxExtract;

Also in case you weren't aware, Items are singletons, so any fields you set in your Item classes are shared among all instances of that Item across the game world.

Ok I made my code like Draco18's

public class PowerArmor extends ArmorItem {
	public EnergyStorage storage;
	public LazyOptional<EnergyStorage> storageHolder = LazyOptional.of(() -> storage);

	public PowerArmor(IArmorMaterial materialIn, EquipmentSlotType slot, Properties builder) {
		super(materialIn, slot, builder);
		this.storage = new EnergyStorage(10000, 1000, 1000, 123); // 123 is just a test
	}

	@Override
	public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return new ICapabilityProvider() {
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				if (cap == CapabilityEnergy.ENERGY) {
					return storageHolder.cast();
				}
				return null;
			}
		};
	}

	@Override
	public void addInformation(ItemStack stack, @Nullable World worldIn, List<ITextComponent> tooltip,
			ITooltipFlag flagIn) {
		String something = "what do I put here";
		tooltip.add(new TranslationTextComponent(
				"Charge: " + something));
	}
}

Is this correct?
Also, how do I get the charge?

How do I do that?

34 minutes ago, diesieben07 said:

You need to do this in your capability provider.

 

What are you referring to when you say capability provider?

public class PowerArmor extends ArmorItem {
	public EnergyStorage storage;

	public PowerArmor(IArmorMaterial materialIn, EquipmentSlotType slot, Properties builder) {
		super(materialIn, slot, builder);
		this.storage = new EnergyStorage(10000, 1000, 1000);
	}

	@Override
	public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return new ICapabilityProvider() {
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				if (cap == CapabilityEnergy.ENERGY) {
					
					LazyOptional<EnergyStorage> storageHolder = LazyOptional.of(() -> storage);
					return storageHolder.cast();
				}
				return null;
			}
		};
	}

	@Override
	public void addInformation(ItemStack stack, @Nullable World worldIn, List<ITextComponent> tooltip,
			ITooltipFlag flagIn) {
		String something = "what do I put here";
		tooltip.add(new TranslationTextComponent(
				"Charge: " + something));
	}
}

Like this?
 

public class PowerArmor extends ArmorItem {
	//public EnergyStorage storage;
	private int capacity;
	private int input;
	private int output;

	public PowerArmor(IArmorMaterial materialIn, EquipmentSlotType slot, Properties builder) {
		super(materialIn, slot, builder);
		//this.storage = new EnergyStorage(10000, 1000, 1000);
		this.capacity = 10000;
		this.input = 1000;
		this.output = 1000;
	}

	@Override
	public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return new ICapabilityProvider() {
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				if (cap == CapabilityEnergy.ENERGY) {
					EnergyStorage storage = new EnergyStorage(capacity, input, output);
					LazyOptional<EnergyStorage> storageHolder = LazyOptional.of(() -> storage);
					return storageHolder.cast();
				}
				return null;
			}
		};
	}
}

maybe like this?

That returns a new instance each time, so I need to store it somewhere?

initCapabilities is called once per item stack, you don't need to worry about calling new there.

What you do need to worry about is not calling new inside getCapability

Hint: inside new ICapabilityProvider() { } is a class.

Edited June 21, 20205 yr by Draco18s

@Override
	public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return new ICapabilityProvider() {
			EnergyStorage storage = new EnergyStorage(capacity, input, output);
			LazyOptional<EnergyStorage> storageHolder = LazyOptional.of(() -> storage);
			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				if (cap == CapabilityEnergy.ENERGY) {
					return storageHolder.cast();
				}
				return null;
			}
		};
	}

I moved it into ICapabilityProvider(), but it is still constantly changing
this.initCapabilities(stack, stack.serializeNBT()).getCapability(CapabilityEnergy.ENERGY, null)
and
this.initCapabilities(stack, stack.serializeNBT()).getCapability(CapabilityEnergy.ENERGY, null).orElse(null)

also I put this in
public void addInformation(ItemStack stack, @Nullable World worldIn, List<ITextComponent> tooltip, ITooltipFlag flagIn)
for testing

Edited June 21, 20205 yr by TallYate
it's in addInformation

Capabilities aren't sync'd to the client automatically.

1 hour ago, TallYate said:

this.initCapabilities(stack, stack.serializeNBT()).getCapability(CapabilityEnergy.ENERGY, null)

That is not how you get a capability. Minecraft calls that method automatically when an item stack of your item is created. Do not call it yourself.

Call getCapability on the stack instead.

Thank you for that, it has stopped spam changing
It is not charging in chargers though, but it does suck up power when it is taken out. You can see what I want to happen with the Industrial Foregoing Drill
 

public class PowerArmor extends ArmorItem {
	public PowerArmor(IArmorMaterial materialIn, EquipmentSlotType slot, Properties builder) {
		super(materialIn, slot, builder);
	}
	
	private EnergyStorage newStorage() {
		return new EnergyStorage(10000, 1000, 1000);
	}
	
	@Override
	public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundNBT nbt) {
		return new ICapabilityProvider() {
			protected EnergyStorage storage = newStorage();
			protected LazyOptional<EnergyStorage> storageHolder = LazyOptional.of(() -> storage);

			@Override
			public <T> LazyOptional<T> getCapability(Capability<T> cap, Direction side) {
				if (cap == CapabilityEnergy.ENERGY) {
					return storageHolder.cast();
				}
				return LazyOptional.empty();
			}
		};
	}

	@Override
	public void addInformation(ItemStack stack, @Nullable World worldIn, List<ITextComponent> tooltip,
			ITooltipFlag flagIn) {
		IEnergyStorage cap = stack.getCapability(CapabilityEnergy.ENERGY, null).orElseGet(null);
		String charge = Integer.toString(cap.getEnergyStored());
		String capacity = Integer.toString(cap.getMaxEnergyStored());
		tooltip.add(new TranslationTextComponent("Charge: " + charge + "/" + capacity));
	}
}

https://streamable.com/pi8evu

1 hour ago, Draco18s said:

Capabilities aren't sync'd to the client automatically.

 

Ok, so how do I sync it?

1 hour ago, TallYate said:

Ok, so how do I sync it?

Packets.

@Override
	@Nullable
	public CompoundNBT getShareTag(ItemStack stack) {
		CompoundNBT tag = stack.getOrCreateTag();
		stack.getCapability(CapabilityEnergy.ENERGY, null).ifPresent(handler -> {tag.putInt("Energy", stack.getCapability(CapabilityEnergy.ENERGY).orElseGet(null).getEnergyStored());});
		return tag;
	}
	
	@Override
	public void readShareTag(ItemStack stack, @Nullable CompoundNBT nbt)
    {
        stack.setTag(nbt);
        int energy = stack.getCapability(CapabilityEnergy.ENERGY, null).orElse(null).getEnergyStored();
        energy=nbt.getInt("Energy");
    }

I feel like I have done the readShareTag part wrong