CAPABILITY PROBLEM

//IPlayerHandler
public interface IPlayerHandler {

    void setChakra(float amount);
    void addChakra(float amount);
    float returnChakra();


    void setmaxChakra(float amount);
    void addmaxChakra(float amount);
    float returnmaxChakra();


    void setregenChakra(float amount);
    void addregenChakra(float amount);
    float returnregenChakra();


    void setjoinWorld(boolean joined);
    boolean joinWorld();


    void setcolorChakra(int amount);
    int returncolorChakra();

    void setplayerEyeSlot(int amount);
    int returnplayerEyeSlot();

    void setTaijutsu(int amount);
    void addTaijutsu(int amount);
    int returnTaijutsu();

    void setBeNMPoints(int amount);
    void addBeNMPoints(int amount);
    int returnBeNMPoints();

    void setChakraControl(float amount);
    void addChakraControl(float amount);
    float returnChakraControl();

    void setPlayerEntityAffiliation(String entityAffiliation);
    String returnPlayerEntityAffiliation();


    void setKeybind1(String k1name);
    void setKeybind2(String k2name);
    void setKeybind3(String k3name);
    void setKeybind4(String k4name);
    void setKeybind5(String k5name);
    void setKeybind6(String k6name);
    void setKeybind7(String k7name);
    void setKeybind8(String k8name);
    void setKeybind9(String k9name);

    String returnKeybind1();
    String returnKeybind2();
    String returnKeybind3();
    String returnKeybind4();
    String returnKeybind5();
    String returnKeybind6();
    String returnKeybind7();
    String returnKeybind8();
    String returnKeybind9();

    void setCloneJutsuBoolean(boolean has);
    void setBodyReplacementBoolean(boolean has);
    void setInvisibilityBoolean(boolean has);
    void setSummoningBoolean(boolean has);
    void setFireballJutsuBoolean(boolean has);
    void setGalePalmJutsuBoolean(boolean has);
    void setFlyingStonesJutsuBoolean(boolean has);
    void setWaterShurikenJutsuBoolean(boolean has);
    void setLightningBallJutsuBoolean(boolean has);
    boolean hasCloneJutsuBoolean();
    boolean hasBodyReplacementBoolean();
    boolean hasInvisibilityBoolean();
    boolean hasSummoningBoolean();
    boolean hasFireballJutsuBoolean();
    boolean hasGalePalmJutsuBoolean();
    boolean hasFlyingStonesJutsuBoolean();
    boolean hasWaterShurikenJutsuBoolean();
    boolean hasLightningBallJutsuBoolean();












//Player Capability
public class PlayerCapability implements IPlayerHandler {

    private String key1;
    private String key2;
    private String key3;
    private String key4;
    private String key5;
    private String key6;
    private String key7;
    private String key8;
    private String key9;

    private float chakra;
    private float maxchakra;
    private float regenchakra;
    private float chakraControl;
    private int chakracolor;
    private int playereyeslot;
    private int taijutsu;
    private int benmpoints;
    private String entityAffiliation;
    private boolean cloneJutsu;
    private boolean replacementJutsu;
    private boolean summoningJutsu;
    private boolean invisibilityJutsu;
    private boolean fireballJutsu;
    private boolean waterShurikenJutsu;
    private boolean galePalmJutsu;
    private boolean flyingStonesJutsu;
    private boolean lightningBallJutsu;
    private boolean joined;

    @Override
    public float returnChakra() {
        return this.chakra;
    }
    @Override
    public void setChakra(float amount) {
        this.chakra = amount;
    }
    @Override
    public void addChakra(float amount) {
        this.chakra += amount;

        if (this.chakra > this.maxchakra)
            this.chakra = this.maxchakra;

        if (this.chakra < 0)
            this.chakra = 0;
    }


    @Override
    public boolean joinWorld() {
        return this.joined;
    }
    @Override
    public void setjoinWorld(boolean joined) {
        this.joined = joined;
    }


    @Override
    public void setmaxChakra(float amount) {
        this.maxchakra = amount;
    }
    @Override
    public void addmaxChakra(float amount) {
        this.maxchakra += amount;
    }
    @Override
    public float returnmaxChakra() {
        return this.maxchakra;
    }


    @Override
    public void setregenChakra(float amount) {
        this.regenchakra = amount;
    }
    @Override
    public void addregenChakra(float amount) {
        this.regenchakra += amount;
    }
    @Override
    public float returnregenChakra() {
        return this.regenchakra;
    }


    @Override
    public void setcolorChakra(int amount) {
        this.chakracolor = amount;
    }
    @Override
    public int returncolorChakra() {
        return this.chakracolor;
    }


    @Override
    public void setplayerEyeSlot(int amount)
    {
        this.playereyeslot = amount;
    }
    @Override
    public int returnplayerEyeSlot()
    {
        return this.playereyeslot;
    }


    @Override
    public void setTaijutsu(int amount)
    {
        this.taijutsu = amount;
    }
    @Override
    public void addTaijutsu(int amount)
    {
        this.taijutsu += amount;

        if (this.taijutsu > 20)
        {
            this.taijutsu = 20;
        }

        if (this.taijutsu < 0)
        {
            this.taijutsu = 0;
        }
    }
    @Override
    public int returnTaijutsu()
    {
        return this.taijutsu;
    }


    @Override
    public void setBeNMPoints(int amount)
    {
        this.benmpoints = amount;
    }
    @Override
    public void addBeNMPoints(int amount)
    {
        this.benmpoints += amount;
    }
    @Override
    public int returnBeNMPoints()
    {
        return this.benmpoints;
    }


    @Override
    public void setChakraControl(float amount)
    {
        this.chakraControl = amount;
    }
    @Override
    public void addChakraControl(float amount)
    {
        this.chakraControl += amount;
    }
    @Override
    public float returnChakraControl()
    {
        return this.chakraControl;
    }


    @Override
    public void setPlayerEntityAffiliation(String entityAffiliation)
    {
        this.entityAffiliation = entityAffiliation;
    }
    @Override
    public String returnPlayerEntityAffiliation()
    {
        return this.entityAffiliation;
    }


    @Override
    public void setKeybind1(String name)
    {
        this.key1 = name;
    }
    @Override
    public String returnKeybind1()
    {
        return this.key1;
    }
    @Override
    public void setKeybind2(String name)
    {
        this.key2 = name;
    }
    @Override
    public String returnKeybind2()
    {
        return this.key2;
    }
    @Override
    public void setKeybind3(String name)
    {
        this.key3 = name;
    }
    @Override
    public String returnKeybind3()
    {
        return this.key3;
    }
    @Override
    public void setKeybind4(String name)
    {
        this.key4 = name;
    }
    @Override
    public String returnKeybind4()
    {
        return this.key4;
    }
    @Override
    public void setKeybind5(String name)
    {
        this.key5 = name;
    }
    @Override
    public String returnKeybind5()
    {
        return this.key5;
    }
    @Override
    public void setKeybind6(String name)
    {
        this.key6 = name;
    }
    @Override
    public String returnKeybind6()
    {
        return this.key6;
    }
    @Override
    public void setKeybind7(String name)
    {
        this.key7 = name;
    }
    @Override
    public String returnKeybind7()
    {
        return this.key7;
    }
    @Override
    public void setKeybind8(String name)
    {
        this.key8 = name;
    }
    @Override
    public String returnKeybind8()
    {
        return this.key8;
    }
    @Override
    public void setKeybind9(String name)
    {
        this.key9 = name;
    }
    @Override
    public String returnKeybind9()
    {
        return this.key9;
    }


    @Override
    public void setCloneJutsuBoolean(boolean has)
    {
        this.cloneJutsu = has;
    }
    @Override
    public boolean hasCloneJutsuBoolean()
    {
        return this.cloneJutsu;
    }
    @Override
    public void setBodyReplacementBoolean(boolean has)
    {
        this.replacementJutsu = has;
    }
    @Override
    public boolean hasBodyReplacementBoolean()
    {
        return this.replacementJutsu;
    }
    @Override
    public void setInvisibilityBoolean(boolean has)
    {
        this.invisibilityJutsu = has;
    }
    @Override
    public boolean hasInvisibilityBoolean()
    {
        return this.invisibilityJutsu;
    }
    @Override
    public void setSummoningBoolean(boolean has)
    {
        this.summoningJutsu = has;
    }
    @Override
    public boolean hasSummoningBoolean()
    {
        return this.summoningJutsu;
    }

    @Override
    public void setFireballJutsuBoolean(boolean has)
    {
        this.fireballJutsu = has;
    }
    @Override
    public boolean hasFireballJutsuBoolean()
    {
        return this.fireballJutsu;
    }

    @Override
    public void setWaterShurikenJutsuBoolean(boolean has)
    {
        this.waterShurikenJutsu = has;
    }
    @Override
    public boolean hasWaterShurikenJutsuBoolean()
    {
        return this.waterShurikenJutsu;
    }

    @Override
    public void setFlyingStonesJutsuBoolean(boolean has)
    {
        this.flyingStonesJutsu = has;
    }
    @Override
    public boolean hasFlyingStonesJutsuBoolean()
    {
        return this.flyingStonesJutsu;
    }

    @Override
    public void setGalePalmJutsuBoolean(boolean has)
    {
        this.galePalmJutsu = has;
    }
    @Override
    public boolean hasGalePalmJutsuBoolean()
    {
        return this.galePalmJutsu;
    }

    @Override
    public void setLightningBallJutsuBoolean(boolean has)
    {
        this.lightningBallJutsu = has;
    }
    @Override
    public boolean hasLightningBallJutsuBoolean()
    {
        return this.lightningBallJutsu;
    }

    public static class Storage implements Capability.IStorage<IPlayerHandler>
    {
        @Nullable
        @Override
        public INBT writeNBT(Capability<IPlayerHandler> capability, IPlayerHandler instance, Direction side)
        {
            CompoundNBT tag = new CompoundNBT();

            tag.putBoolean("joined", instance.joinWorld());
            tag.putFloat("chakra", instance.returnChakra());
            tag.putFloat("maxchakra", instance.returnmaxChakra());
            tag.putFloat("regenchakra", instance.returnregenChakra());
            tag.putFloat("chakracontrol", instance.returncolorChakra());
            tag.putInt("colorchakra", instance.returncolorChakra());
            tag.putInt("taijutsu", instance.returnTaijutsu());
            tag.putInt("benmpoints", instance.returnBeNMPoints());
            tag.putInt("playereyeslot", instance.returnplayerEyeSlot());
            tag.putString("playeraffiliation", instance.returnPlayerEntityAffiliation());

            //Keybinds for Jutsu
            tag.putString("key1", instance.returnKeybind1());
            tag.putString("key2", instance.returnKeybind2());
            tag.putString("key3", instance.returnKeybind3());
            tag.putString("key4", instance.returnKeybind4());
            tag.putString("key5", instance.returnKeybind5());
            tag.putString("key6", instance.returnKeybind6());
            tag.putString("key7", instance.returnKeybind7());
            tag.putString("key8", instance.returnKeybind8());
            tag.putString("key9", instance.returnKeybind9());

            //Jutsu
            tag.putBoolean("clone", instance.hasCloneJutsuBoolean());
            tag.putBoolean("invisibility", instance.hasInvisibilityBoolean());
            tag.putBoolean("summoning", instance.hasSummoningBoolean());
            tag.putBoolean("replacement", instance.hasBodyReplacementBoolean());
            //Fire
            tag.putBoolean("fireball", instance.hasFireballJutsuBoolean());
            //Water
            tag.putBoolean("watershuriken", instance.hasWaterShurikenJutsuBoolean());
            //Wind
            tag.putBoolean("galepalm", instance.hasGalePalmJutsuBoolean());
            //Earth
            tag.putBoolean("flyingstones", instance.hasFlyingStonesJutsuBoolean());
            //Lightning
            tag.putBoolean("lightningball", instance.hasLightningBallJutsuBoolean());
            return tag;
        }

        @Override
        public void readNBT(Capability<IPlayerHandler> capability, IPlayerHandler instance, Direction side, INBT nbt)
        {
            INBT tag = new CompoundNBT();
            instance.setjoinWorld(((CompoundNBT) tag).getBoolean("joined"));
            instance.setChakra(((CompoundNBT) tag).getFloat("chakra"));
            instance.setmaxChakra(((CompoundNBT) tag).getFloat("maxchakra"));
            instance.setregenChakra(((CompoundNBT) tag).getFloat("regenchakra"));
            instance.setcolorChakra(((CompoundNBT) tag).getInt("colorchakra"));
            instance.setTaijutsu(((CompoundNBT) tag).getInt("taijutsu"));
            instance.setplayerEyeSlot(((CompoundNBT) tag).getInt("playereyeslot"));
            instance.setBeNMPoints(((CompoundNBT) tag).getInt("benmpoints"));
            instance.setPlayerEntityAffiliation(((CompoundNBT) tag).getString("playeraffiliation"));

            //Keybinds for Jutsu
            instance.setKeybind1(((CompoundNBT) tag).getString("key1"));
            instance.setKeybind2(((CompoundNBT) tag).getString("key2"));
            instance.setKeybind3(((CompoundNBT) tag).getString("key3"));
            instance.setKeybind4(((CompoundNBT) tag).getString("key4"));
            instance.setKeybind5(((CompoundNBT) tag).getString("key5"));
            instance.setKeybind6(((CompoundNBT) tag).getString("key6"));
            instance.setKeybind7(((CompoundNBT) tag).getString("key7"));
            instance.setKeybind8(((CompoundNBT) tag).getString("key8"));
            instance.setKeybind9(((CompoundNBT) tag).getString("key9"));

            //Jutsu
            instance.setCloneJutsuBoolean(((CompoundNBT) tag).getBoolean("clone"));
            instance.setSummoningBoolean(((CompoundNBT) tag).getBoolean("summoning"));
            instance.setInvisibilityBoolean(((CompoundNBT) tag).getBoolean("invisibility"));
            instance.setBodyReplacementBoolean(((CompoundNBT) tag).getBoolean("replacement"));
            //Fire
            instance.setFireballJutsuBoolean(((CompoundNBT) tag).getBoolean("fireball"));
            //Water
            instance.setWaterShurikenJutsuBoolean(((CompoundNBT) tag).getBoolean("watershuriken"));
            //Lightning
            instance.setLightningBallJutsuBoolean(((CompoundNBT) tag).getBoolean("lightningball"));
            //Earth
            instance.setFlyingStonesJutsuBoolean(((CompoundNBT) tag).getBoolean("flyingstones"));
            //Wind
            instance.setGalePalmJutsuBoolean(((CompoundNBT) tag).getBoolean("galepalm"));
        }
    }
}










//PlayerProvider
public class PlayerProvider implements ICapabilitySerializable<INBT> {
    @CapabilityInject(IPlayerHandler.class)
    public static final Capability<IPlayerHandler> CAPABILITY_PLAYER = null;

    private LazyOptional<IPlayerHandler> instance = LazyOptional.of(CAPABILITY_PLAYER::getDefaultInstance); //getDefaultInstance

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


    @Override
    public void deserializeNBT(INBT nbt) {
        System.out.println("Called");
        CAPABILITY_PLAYER.getStorage().readNBT(CAPABILITY_PLAYER, instance.orElseThrow(() -> new IllegalArgumentException("LazyOptional is empty")),null, nbt);

    }

    @Override
    public INBT serializeNBT() {
        System.out.println("Called");
        return CAPABILITY_PLAYER.getStorage().writeNBT(CAPABILITY_PLAYER, instance.orElseThrow(() -> new IllegalArgumentException("LazyOptional is empty")),null);
    }
}








//CapabilityHandler
public class CapabilityHandler {

    public static final ResourceLocation CAPABILITY_PLAYER = new ResourceLocation(Main.MODID, "player");

    @Mod.EventBusSubscriber
    public static class capabilityAttacher {
        @SubscribeEvent
        public static void attachCapability(AttachCapabilitiesEvent<Entity> event) {
            if (!(event.getObject() instanceof PlayerEntity)) return;

            event.addCapability(CAPABILITY_PLAYER, new PlayerProvider());
        }
    }
}