Hello Developers Usually older versions use Capability to save numeric values or other values via CompoundNBT via the forge library but in this version I tried to rebuild Capability but when using getCapability from Player class it turns out that Capability The new class doesn't match the old one. So I looked in vanilla and found CapabilityEnergy, EnergyStorage and IEnergyStorage so I looked at CapabilityEnergy#register because this method should is @SubscribeEvent to register IEnergyStorage But I don't know how to import or register EnergyStorage. I know EnergyStorage implements IEnergyStorage.

What I want to know is EnergyStorage How can it be used?

--------------------------------------------[1.16.5]--------------------------------------------
I created the IStatus interface, it doesn't implements and extends.
Then I created the class Status implements IStatus.
Next, I created a class StatusStorage implements IStorage<IStatus> to write and read CompoundNBT.
Finally, I created a class StatusProvider implements ICapabilitySerializable<INBT> and applied Capability<IStatus> to LazyOptional#of .

Everything went well.

--------------------------------------------[1.17.1]--------------------------------------------
First, Capability<T> doesn't have getDefaultInstance , so create a newCapability<T> for use with LazyOptional#of() .
Once it was created, I added the getDefaultInstance method to the NewCapability<T> similar to the old version.
But when to take Player#getCapability is used, it turns out CapabilityNew<T> is not Capability<T> , so it cannot be put in Player#getCapability
So I extends Capability<T> into NewCapability<T> , it can be used in Player#getCapability .
Later I ran into a problem: Capability(string) was not public, so I couldn't extends it.

So I would like to use the same method as your library as mentioned above. but i don't know EnergyStorage, can it register?

Below is the code I wrote in 1.16.5 for saving the values to the player. (P.S. besides not having getDefaultInstance and there is no getStorage() yet.)

public interface IStatus
{
    public void setEnergy(int points);
    
    public int getEnergy();
    
    public void setExcretion(int points);
    
    public int getExcretion();
    
    public void setDirty(int points);
    
    public int getDirty();
}

 

public class Status implements IStatus
{
    private int energy;
    private int excretion;
    private int dirty;
    
    public Status() {
    	this.energy = 20;
    	this.excretion = 20;
    	this.dirty = 20;
    }
    
	@Override
	public void setEnergy(int points) {
		this.energy = points;
	}
	
	@Override
	public int getEnergy() {
		return this.energy;
	}

	@Override
	public void setExcretion(int points) {
		this.excretion = points;
	}

	@Override
	public int getExcretion() {
		return this.excretion;
	}

	@Override
	public void setDirty(int points) {
		this.dirty = points;
	}

	@Override
	public int getDirty() {
		return this.dirty;
	}
}

 

public class StatusProvider implements ICapabilitySerializable<INBT>
{
    @CapabilityInject(IStatus.class)
    public static final Capability<IStatus> Status_CAP = null;
    
    private LazyOptional<IStatus> instance = LazyOptional.of(Status_CAP::getDefaultInstance);
    
    @Override
    public <T> LazyOptional<T> getCapability(Capability<T> capability, Direction side)
    {
        return capability == Status_CAP ? instance.cast() : LazyOptional.empty();
    }
    
    @Override
    public INBT serializeNBT()
    {
        return Status_CAP.getStorage().writeNBT(Status_CAP, this.instance.orElseThrow(() -> new IllegalArgumentException("LazyOptional must not be empty!")), null);
    }
    
    @Override
    public void deserializeNBT(INBT nbt)
    {
    	Status_CAP.getStorage().readNBT(Status_CAP, this.instance.orElseThrow(() -> new IllegalArgumentException("LazyOptional must not be empty!")), null, nbt);
    }
}

 

public class StatusStorage implements IStorage<IStatus>
{
    @Override
    public INBT writeNBT(Capability<IStatus> capability, IStatus instance, Direction side)
    {
    	CompoundNBT status = new CompoundNBT();
    	status.putInt("Energy", instance.getEnergy());
    	status.putInt("Excretion", instance.getExcretion());
    	status.putInt("Dirty", instance.getDirty());
        return status;
    }

    @Override
    public void readNBT(Capability<IStatus> capability, IStatus instance, Direction side, INBT nbt)
    {
    	CompoundNBT status = (CompoundNBT)nbt;
    	instance.setEnergy(status.getInt("Energy"));
    	instance.setExcretion(status.getInt("Excretion"));
    	instance.setDirty(status.getInt("Dirty"));
    }
}

 

I need some advice from you. If you want to write a program to save the values in the player, which objects and methods should be used respectively, or just use CompoundTag? Run it now I'm disturbed

P.S. Your library is awesome.

Ummmmmmm So what method do you use when you don't have one? getDefaultInstance() method in combination with LazyOptional ?

You mean creating a new Capability and adding some methods to throw, right?

Player#getCapability It cannot be used in conjunction with the Capability I created myself.

Player#getCapability usually uses Capability<T> capability, Direction facing, but I renamed the class to NewCapability<T> I'm not sure. is it related? because originally it was net.minecraftforge.common.capabilities.Capability<T> is not something I created.

23 minutes ago, zlappedx3 said:

because originally it was net.minecraftforge.common.capabilities.Capability<T> is not something I created.

And you still don't.

What should I do with this log?

Spoiler

The method getCapability(Capability<T>, Direction) in the type Player is not applicable for the arguments (Capability<IStatus>, null)

 

25 minutes ago, Draco18s said:

And you still don't.

Maybe if you change

    Capability(String name)
    {
        this.name = name;
    }

To
 

    public Capability(String name)
    {
        this.name = name;
    }

on package net.minecraftforge.common.capabilities.Capability i can do it

You don't create an instance of the `Capability` class, that is still handled behind the scenes (and the `@CapabilityInject` annotation still works as before).

Where you called `Capability#getDefaultInstance()` before, just create your new instance (of your Capability type, i.e. `new Status()`).

Where you called your Storage class methods (from your Capability Provider), just move your saving/loading stuff directly into those methods of your `StatusProvider`.

Should I make StatusProvider an instance?

7 minutes ago, zlappedx3 said:

Should I make StatusProvider an instance?

What? You use StatusProvider exactly the same way you did before (attaching it in the AttachCapabilitiesEvent). The only thing you change is in your StatusProvider, you move the old code from your CapabilityRegistry.register(cap_class, storage, default_factory) and put the code from the storage class inside your StatusProvider save/load methods, and the code from your default_factory inside your LazyOptional.

Literally just getting rid of the stuff that no longer exists and calling it directly, instead of through the capability.

<nevermind, wrong info>

Edited September 30, 20213 yr by Luis_ST

Just now, Luis_ST said:

@Alpvaxthis is 1.16, storage and factory have been removed in 1.17.
please edit the posts you create and remove the wrong information

Yes, that is what I am saying. Remove the old code (from the storage / default factory, which no longer exists) and put it in the Capability Provider directly.

21 minutes ago, zlappedx3 said:

Should I make StatusProvider an instance?

do something like that
and use RegisterCapabilitiesEvent to register your Cap

Edited September 30, 20213 yr by Luis_ST

Thank you verry mush for example.