Не сохраняется capability после пере захода

[Darth]

сама дата

public class PlayerData {

    private int legacyId;
    private String ability1 = "none";
    private String ability2 = "none";
    private String ability3 = "none";
    private String ability4 = "none";
    private String ability5 = "none";
    private String special = "none";
    private String equip = "none";
    private int tickLegacy;
    public PlayerEntity player;
    private float tick;

    public PlayerData(PlayerEntity ep) {
        player = ep;
    }

    public PlayerData() {

    }

    
    public int getLegacy() {
        return legacyId;
    }

    
    public void setLegacy(int legacy) {
        legacyId = legacy;
        syncToAll();
    }

    public void copyFrom(PlayerData source) {
        legacyId = source.legacyId;
        ability1 = source.ability1;
        ability2 = source.ability2;
        ability3 = source.ability3;
        ability4 = source.ability4;
        ability5 = source.ability5;
        special = source.special;
        equip = source.equip;
        tickLegacy = source.tickLegacy;
        tick = source.tick;
    }

    public CompoundNBT serializeNBT() {
        CompoundNBT nbt = new CompoundNBT();
        nbt.putInt("legacy_id", legacyId);
        nbt.putString("ability1", ability1);
        nbt.putString("ability2", ability2);
        nbt.putString("ability3", ability3);
        nbt.putString("ability4", ability4);
        nbt.putString("ability5", ability5);
        nbt.putString("ability_special", special);
        nbt.putString("ability_equip", equip);
        nbt.putInt("tick_legacy", tickLegacy);
        nbt.putFloat("tick", tick);
        return nbt;
    }

    public void deserializeNBT(CompoundNBT nbt) {
        legacyId = nbt.getInt("legacy_id");
        ability1 = nbt.getString("ability1");
        ability2 = nbt.getString("ability2");
        ability3 = nbt.getString("ability3");
        ability4 = nbt.getString("ability4");
        ability5 = nbt.getString("ability5");
        special = nbt.getString("ability_special");
        equip = nbt.getString("ability_equip");
        tickLegacy = nbt.getInt("tick_legacy");
        tick = nbt.getFloat("tick");

    }

    public PlayerData sync() {
        if (this.player instanceof ServerPlayerEntity) {
            EHPacketManager.INSTANCE.sendTo(new ClientPacketSyncLegacy(this.player.getEntityId(), this.serializeNBT()), ((ServerPlayerEntity) this.player).connection.getNetworkManager(), NetworkDirection.PLAY_TO_CLIENT);
        }

        return this;
    }

    public PlayerData syncToAll() {
        this.sync();
        if (player != null) {
            for (PlayerEntity p : this.player.world.getPlayers()) {
                if (p instanceof ServerPlayerEntity) {
                    EHPacketManager.INSTANCE.sendTo(new ClientPacketSyncLegacy(this.player.getEntityId(), this.serializeNBT()), ((ServerPlayerEntity) p).connection.getNetworkManager(), NetworkDirection.PLAY_TO_CLIENT);
                }
            }
        }
        return this;
    }

    
    public String getAbility1() {
        return ability1;
    }

    
    public void setAbility1(String s) {
        ability1 = s;
        syncToAll();
    }

    
    public String getAbility2() {
        return ability2;
    }

    
    public void setAbility2(String s) {
        ability2 = s;
        syncToAll();
    }

    
    public String getAbility3() {
        return ability3;
    }

    
    public void setAbility3(String s) {
        ability3 = s;
        syncToAll();
    }

    
    public String getAbility4() {
        return ability4;

    }

    
    public void setAbility4(String s) {
        ability4 = s;
        syncToAll();
    }

    
    public String getAbility5() {
        return ability5;
    }

    
    public void setAbility5(String s) {
        ability5 = s;
        syncToAll();
    }

    
    public String getEquip() {
        return equip;

    }

    
    public void setEquip(String s) {
        equip = s;
        syncToAll();
    }

    
    public String getSpecial() {
        return special;
    }

    
    public void setSpecial(String s) {
        special = s;
        syncToAll();
    }

    public int getTickLegacy() {
        return tickLegacy;
    }

    public void setTickLegacy(int t) {
        tickLegacy = t;
        syncToAll();
    }

    public void setTickSpeed(float s) {
        tick = s;
        syncToAll();
    }

    public float getTickSpeed() {
        return tick;
    }

    public void updateLegacyTick() {
        if (tickLegacy < 100) {
            ++tickLegacy;
        }
    }
}

Storage

public class PlayerDataStorage implements Capability.IStorage<PlayerData> {

    public INBT writeNBT(Capability<PlayerData> capability, PlayerData instance, Direction side) {
        CompoundNBT nbt = new CompoundNBT();
        nbt.putInt("legacy_id", instance.getLegacy());
        nbt.putString("ability1", instance.getAbility1());
        nbt.putString("ability2", instance.getAbility2());
        nbt.putString("ability3", instance.getAbility3());
        nbt.putString("ability4", instance.getAbility4());
        nbt.putString("ability5", instance.getAbility5());
        nbt.putString("ability_special", instance.getSpecial());
        nbt.putString("ability_equip", instance.getEquip());
        nbt.putInt("tick_legacy", instance.getTickLegacy());
        nbt.putFloat("tick", instance.getTickSpeed());//getTick());
        return nbt;
    }

    public void readNBT(Capability<PlayerData> capability, PlayerData instance, Direction side, INBT nbt) {
        CompoundNBT tag = (CompoundNBT) nbt;
        instance.setAbility1(tag.getString("ability1"));
        instance.setAbility2(tag.getString("ability2"));
        instance.setAbility3(tag.getString("ability3"));
        instance.setAbility4(tag.getString("ability4"));
        instance.setAbility5(tag.getString("ability5"));
        instance.setLegacy(tag.getInt("legacy_id"));
        instance.setSpecial(tag.getString("ability_special"));
        instance.setEquip(tag.getString("ability_equip"));
        instance.setTickLegacy(tag.getInt("tick_legacy"));
        instance.setTickSpeed(tag.getInt("tick"));
    }

}

Provider

public class PlayerCAP implements ICapabilitySerializable<INBT> {

    @CapabilityInject(PlayerData.class)
    public static Capability<PlayerData> PLAYER_LEGACY = null;
    private final PlayerData instanceData = PLAYER_LEGACY.getDefaultInstance();
    private final LazyOptional instance;

    public PlayerCAP(PlayerEntity pe) {
        this.instance = LazyOptional.of(() -> {
            return new PlayerData(pe);
        });


    }

  
    public CompoundNBT serializeNBT() {
        return  (CompoundNBT) PLAYER_LEGACY.getStorage().writeNBT(PLAYER_LEGACY, instanceData, null);
    }

    @Nonnull
    public LazyOptional getCapability(@Nonnull Capability cap, @Nullable Direction side) {
        return cap == PLAYER_LEGACY ? this.instance.cast() : LazyOptional.empty();
    }

 
    public void deserializeNBT(INBT t) {
        PLAYER_LEGACY.getStorage().readNBT(PLAYER_LEGACY, instanceData, null, t);
    }
}

Эвент

  @SubscribeEvent
    public static void onAttachCapabilitiesPlayer(AttachCapabilitiesEvent<Entity> event) {
        if (event.getObject() instanceof PlayerEntity) {
            event.addCapability(new ResourceLocation(Main.MODID, ("eh_player")), new PlayerCAP((PlayerEntity) event.getObject()));
        }
    }

    @SubscribeEvent
    public static void onPlayerCloned(PlayerEvent.Clone event) {
        if (event.isWasDeath()) {
            event.getOriginal().getCapability(PlayerCAP.PLAYER_LEGACY).ifPresent(oldStore -> {
                event.getOriginal().getCapability(PlayerCAP.PLAYER_LEGACY).ifPresent(newStore -> {
                    newStore.copyFrom(oldStore);
                });
            });

        }
    }
    @SubscribeEvent
    public void onStartTracking(StartTracking event) {
        if (event.getPlayer() instanceof ServerPlayerEntity) {
            event.getTarget().getCapability(PlayerCAP.PLAYER_LEGACY).ifPresent((cap) -> {
                ServerPlayerEntity spe = (ServerPlayerEntity) event.getPlayer();
                EHPacketManager.INSTANCE.sendTo(new ClientPacketSyncLegacy(event.getTarget().getEntityId(), (CompoundNBT) cap.serializeNBT()), spe.connection.getNetworkManager(), NetworkDirection.PLAY_TO_CLIENT);
            });
        }
    }

    @SubscribeEvent
    public void onJoinWorld(EntityJoinWorldEvent event) {
        if (event.getEntity() instanceof ServerPlayerEntity) {
            event.getEntity().getCapability(PlayerCAP.PLAYER_LEGACY).ifPresent(PlayerData::syncToAll);
        }
    }

Ну и пакет

public class ClientPacketSyncLegacy {

    public int entityId;
    private final CompoundNBT data;

    public ClientPacketSyncLegacy(int entityId, CompoundNBT data) {
        this.entityId = entityId;
        this.data = data;
    }

    public ClientPacketSyncLegacy(PacketBuffer buf) {
        this.entityId = buf.readInt();
        this.data = buf.readCompoundTag();
    }

    public void toBytes(PacketBuffer buf) {
        buf.writeInt(this.entityId);
        buf.writeCompoundTag(this.data);
    }

    public void handle(Supplier ctx) {
        ((Context) ctx.get()).enqueueWork(() -> {
            Minecraft mc = Minecraft.getInstance();
            Entity entity = mc.world.getEntityByID(this.entityId);
            if (entity instanceof LivingEntity) {
                LivingEntity living = (LivingEntity) entity;
                living.getCapability(PlayerCAP.PLAYER_LEGACY).ifPresent((data1) -> {
                    data1.deserializeNBT(this.data);
                });
            }

        });
        ((Context) ctx.get()).setPacketHandled(true);
    }
}

Ладно ещё регистрация
CapabilityManager.INSTANCE.register(PlayerData.class, new PlayerDataStorage(), PlayerData::new);
Хз че делать после пере захода в мир/игру все на дефолт значениях 0

 

[Darth]

Up