I followed a tutorial on this(https://www.youtube.com/watch?v=My70x9LzeUM&t=297s) because i never had to use capabilities until now, the tutorial is for 1.19 but the process is exactly the same as 1.18.2.

For testing, my capability is the same as the tutorial (thirst for players) but it's not working, when i press a key it removes 1 "thirst" and sends a message but nothing happens, no errors or crashes, i also tried to do the same but with a package sending it to the server just in case, but APPARENTLY AND FOR NOW, it has nothing to do with client and server.

So maybe im attaching the capability to the player wrong? (BTW: the key pressing works correctly, so thats not the problem)

 

public class PlayerThirstProvider implements ICapabilityProvider, INBTSerializable<CompoundTag> {

    public static Capability<PlayerThirst> CAPABILITY_PLAYER_DATA = CapabilityManager.get(new CapabilityToken<>() {});
    private LazyOptional<PlayerThirst> optional = LazyOptional.of(this::create);
    PlayerThirst thirst = null;

    private PlayerThirst create() {
        if(this.thirst == null) {
            this.thirst = new PlayerThirst();
        }
        return this.thirst;
    }



    @NotNull
    @Override
    public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
        if(cap == CAPABILITY_PLAYER_DATA) {
            return optional.cast();
        }
        return LazyOptional.empty();
    }
    @Override
    public CompoundTag serializeNBT() {
        CompoundTag tag = new CompoundTag();
        create().save(tag);
        return tag;
    }

    @Override
    public void deserializeNBT(CompoundTag nbt) {
        create().load(nbt);
    }
}

public class PlayerThirst {

    private int thirst;

    public int getThirst() {
        return this.thirst;
    }

    public void addThirst(int thirst) {
        this.thirst = Math.min(this.thirst + thirst, 10);
    }
    public void subThirst(int thirst) {
        this.thirst = Math.max(this.thirst - thirst, 0);
    }
    public void copyFrom(PlayerThirst source) {
        this.thirst = source.thirst;
    }
    public void save(CompoundTag tag) {
        tag.putInt("thirst", this.thirst);
    }
    public void load(CompoundTag tag) {
        this.thirst = tag.getInt("thirst");
    }
}

 

@Mod.EventBusSubscriber(modid = Constants.MOD_ID)
public abstract class ClientEvents {

  	@SubscribeEvent
        public static void keyPress2(InputEvent.KeyInputEvent event) {
            if(ModKeybinds.MY_KEY.consumeClick()) {
                //ModMessages.sendToServer(new PacketThirst());
                mc.player.getCapability(PlayerThirstProvider.CAPABILITY_PLAYER_DATA).ifPresent(thirst -> {
                    thirst.subThirst(1);
                    mc.player.sendMessage(new TextComponent(""+thirst.getThirst()),mc.player.getUUID());
                });
            }
        }
    @SubscribeEvent
    public static void register(RegisterCapabilitiesEvent event) {
        event.register(PlayerThirst.class);
    }
    @SubscribeEvent
    public void attachCapabilities(AttachCapabilitiesEvent<Entity> event) {
        if (event.getObject() instanceof Player) {
            if(!event.getObject().getCapability(PlayerThirstProvider.CAPABILITY_PLAYER_DATA).isPresent()) {
                event.addCapability(new ResourceLocation(Constants.MOD_ID, "playerdata"), new PlayerThirstProvider());
            }
        }
    }
    @SubscribeEvent
    public static void onPlayerCloned(PlayerEvent.Clone event) {
        if (event.isWasDeath()) {
            event.getOriginal().getCapability(PlayerThirstProvider.CAPABILITY_PLAYER_DATA).ifPresent(oldStore -> {
                event.getPlayer().getCapability(PlayerThirstProvider.CAPABILITY_PLAYER_DATA).ifPresent(newStore -> {
                    newStore.copyFrom(oldStore);
                });
            });
        }
    }
}

public class PacketThirst {

    public PacketThirst() {
    }

    // Read
    public PacketThirst(FriendlyByteBuf buf) {

    }

    public void write(FriendlyByteBuf buf) {
    }

    public boolean handle(Supplier<NetworkEvent.Context> ctx) {
        NetworkEvent.Context context = ctx.get();
        context.enqueueWork(() -> {
            ServerPlayer serverPlayer = context.getSender();
            serverPlayer.getCapability(PlayerThirstProvider.CAPABILITY_PLAYER_DATA).ifPresent(thirst -> {
                thirst.subThirst(1);
                serverPlayer.sendMessage(new TextComponent(""+thirst.getThirst()),serverPlayer.getUUID());
            });
        });
        return true;
    }
}

RegisterCapabilities is fired on the mod event bus, not the forge event bus.

https://forge.gemwire.uk/wiki/Events#Event_Bus

37 minutes ago, warjort said:

RegisterCapabilities is fired on the mod event bus, not the forge event bus.

https://forge.gemwire.uk/wiki/Events#Event_Bus

it didnt work:

 

@Mod.EventBusSubscriber(modid = Constants.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD, value = Dist.CLIENT)
public abstract class ModBusClientEvents {

    @SubscribeEvent
    public static void register(RegisterCapabilitiesEvent event) {
        event.register(PlayerThirst.class);
    }
}

 

Quote

@SubscribeEvent

public void attachCapabilities(AttachCapabilitiesEvent<Entity> event) {

not a static method