Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

[1.16.5] I don't think I fully understand how capabilities work...


cwJn
 Share

Recommended Posts

So I thought that when a capability is attached to an item/entity/etc... the capability will stay until whatever it's attached to is gone. But this doesn't seem to be the case, as when I printed to console whenever a capability is attached, it seems as though a new version of the capability is attached to an item every time I select it in my hotbar, hover over it in inventory, etc. Is this how it's supposed to work? If so, why?

Link to comment
Share on other sites

Show your code.

Apparently I'm a complete and utter jerk and come to this forum just like to make fun of people, be confrontational, and make your personal life miserable.  If you think this is the case, JUST REPORT ME.  Otherwise you're just going to get reported when you reply to my posts and point it out, because odds are, I was trying to be nice.

 

Exception: If you do not understand Java, I WILL NOT HELP YOU and your thread will get locked.

 

DO NOT PM ME WITH PROBLEMS. No help will be given.

Link to comment
Share on other sites

@SubscribeEvent
    public static void ItemHandler(AttachCapabilitiesEvent<ItemStack> event) {
        ItemStack item = event.getObject();
        if (GearApi.isGear(item)) {
            SGearTraitHelperProvider provider = new SGearTraitHelperProvider();
            event.addCapability(TRAIT_HELPER_KEY, provider);
            event.addListener(provider::invalidate);
        }
        if (isArmour(item) || item.getItem() instanceof ICoreArmor) {
            DamageResistanceProvider provider = new DamageResistanceProvider(0, 0, 0, 0, 0, 0, 0, 0, 0);
            event.addCapability(RES_KEY, provider);
            event.addListener(provider::invalidate);
        } else if (isWeapon(item) || item.getItem() instanceof ICoreTool) {
            DamageTypesProvider provider = new DamageTypesProvider(0, 0, 0, 0, 0, 0, 0, 0, 0, "IMPACT");
            event.addCapability(DMG_KEY, provider);
            event.addListener(provider::invalidate);
        }
    }

 

Link to comment
Share on other sites

 

This is the capability inject and provider for one of my capabilities. All of them are coded the exact same way.

public class CapabilityDamageTypes {

    @CapabilityInject(IDamageTypes.class)
    public static Capability<IDamageTypes> DAMAGE_TYPES_CAPABILITY = null;

    public static void register() {
        CapabilityManager.INSTANCE.register(IDamageTypes.class, new Storage(), new Factory());
    }

    private static class Storage implements Capability.IStorage<IDamageTypes> {

        @Nullable
        @Override
        public INBT writeNBT(Capability<IDamageTypes> capability, IDamageTypes instance, Direction side) {
            CompoundNBT tag = new CompoundNBT();
            tag.putFloat("slash", instance.getSlashDamage());
            tag.putFloat("impact", instance.getImpactDamage());
            tag.putFloat("puncture", instance.getPunctureDamage());
            tag.putFloat("fire", instance.getFireDamage());
            tag.putFloat("lightning", instance.getLightningDamage());
            tag.putFloat("ice", instance.getIceDamage());
            tag.putFloat("dark", instance.getDarkDamage());
            tag.putFloat("holy", instance.getHolyDamage());
            tag.putFloat("magic", instance.getMagicDamage());
            tag.putString("mobDamageType", instance.getMobDamageType());
            return tag;
        }

        @Override
        public void readNBT(Capability<IDamageTypes> capability, IDamageTypes instance, Direction side, INBT nbt) {
            float slash = ((CompoundNBT) nbt).getFloat("slash");
            float impact = ((CompoundNBT) nbt).getFloat("impact");
            float puncture = ((CompoundNBT) nbt).getFloat("puncture");
            float fire = ((CompoundNBT) nbt).getFloat("fire");
            float lightning = ((CompoundNBT) nbt).getFloat("lightning");
            float ice = ((CompoundNBT) nbt).getFloat("ice");
            float dark = ((CompoundNBT) nbt).getFloat("dark");
            float holy = ((CompoundNBT) nbt).getFloat("holy");
            float magic = ((CompoundNBT) nbt).getFloat("magic");
            String mobDamageType = ((CompoundNBT) nbt).getString("mobDamageType");

            instance.setSlashDamage(slash);
            instance.setImpactDamage(impact);
            instance.setPunctureDamage(puncture);
            instance.setFireDamage(fire);
            instance.setLightningDamage(lightning);
            instance.setIceDamage(ice);
            instance.setDarkDamage(dark);
            instance.setHolyDamage(holy);
            instance.setMagicDamage(magic);
            instance.setMobDamageType(mobDamageType);
        }
    }

    private static class Factory implements Callable<IDamageTypes> {

        @Override
        public IDamageTypes call() throws Exception {
            return new DamageTypes(0, 0, 0, 0, 0, 0, 0, 0, 0, "IMPACT");
        }

    }

}
package com.cwjn.hardstuckintegration.Capabilities.DamageTypes;

import net.minecraft.nbt.CompoundNBT;
import net.minecraft.util.Direction;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.common.capabilities.ICapabilitySerializable;
import net.minecraftforge.common.util.LazyOptional;

import javax.annotation.Nonnull;
import javax.annotation.Nullable;

public class DamageTypesProvider implements ICapabilitySerializable<CompoundNBT> {

    //private final DamageTypes damage = new DamageTypes();
    //private final LazyOptional<IDamageTypes> damageOptional = LazyOptional.of(() -> damage);
    private DamageTypes damage;
    private LazyOptional<IDamageTypes> damageOptional;

    public void invalidate() {
        damageOptional.invalidate();
    }

    public DamageTypesProvider(float I, float P, float S, float F, float L, float IC, float D, float H, float M, String mobDamageType) {
        damage = new DamageTypes(I, P, S, F, L, IC, D, H, M, mobDamageType);
        damageOptional = LazyOptional.of(() -> damage);
    }

    @Nonnull
    @Override
    public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
        return cap == CapabilityDamageTypes.DAMAGE_TYPES_CAPABILITY ? damageOptional.cast() : LazyOptional.empty();
    }

    @Override
    public CompoundNBT serializeNBT() {
        if (CapabilityDamageTypes.DAMAGE_TYPES_CAPABILITY == null) {
            return new CompoundNBT();
        } else {
            return (CompoundNBT) CapabilityDamageTypes.DAMAGE_TYPES_CAPABILITY.writeNBT(damage, null);
        }
    }

    @Override
    public void deserializeNBT(CompoundNBT nbt) {
        if (CapabilityDamageTypes.DAMAGE_TYPES_CAPABILITY != null) {
            CapabilityDamageTypes.DAMAGE_TYPES_CAPABILITY.readNBT(damage, null, nbt);
        }
    }

}

 

Link to comment
Share on other sites

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.
Note: Your post will require moderator approval before it will be visible.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.

 Share



×
×
  • Create New...

Important Information

By using this site, you agree to our Privacy Policy.