Hey guys!

I'm porting one of my mods from 1.14.4 to 1.18.2 and got stuck with Capabilities. To ensure that I'm not making a mistake elsewhere, I've started a completely new project just for testing and faced the same issue: I cannot copy capability data to new Player instance on PlayerEvent.Clone on Player's death.

My capability class SpiritCapability:
 

public class SpiritCapability {

    public final ArrayList<DeathEventData> deaths = new ArrayList<>();

    public void addDeath(DeathEventType reason, long tod) {
        deaths.add(new DeathEventData(reason, tod));
    }

    public void copyFrom(SpiritCapability source) {
        deaths.clear();
        deaths.addAll(source.deaths);
    }

    public void saveNBTData(CompoundTag compound) {
        compound.putInt("deathCount", deaths.size());
        for (int i = 0; i < deaths.size(); i++) {
            compound.put("dth_" + i, deaths.get(i).getTag());
        }
    }

    public void loadNBTData(CompoundTag compound) {
        deaths.clear();
        int deathCount = compound.getInt("deathCount");
        for (int i = 0; i < deathCount; i++) {
            CompoundTag death = compound.getCompound("dth_" + i);
            deaths.add(new DeathEventData(death));
        }
    }
}

Capability Provider class SpiritCapabilityProvider:
 

public class SpiritCapabilityProvider implements ICapabilityProvider, INBTSerializable<CompoundTag> {

    public static Capability<SpiritCapability> SPIRIT_CAP = CapabilityManager.get(new CapabilityToken<>(){});
    private SpiritCapability spiritCapability = null;
    private final LazyOptional<SpiritCapability> opt = LazyOptional.of(this::createCap);

    @Nonnull
    private SpiritCapability createCap() {
        if (spiritCapability == null) {
            spiritCapability = new SpiritCapability();
        }
        return spiritCapability;
    }

    @NotNull
    @Override
    public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
        return getCapability(cap);
    }

    @NotNull
    @Override
    public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap) {
        if(cap == SPIRIT_CAP)
            return opt.cast();
        else
            return LazyOptional.empty();
    }

    @Override
    public CompoundTag serializeNBT() {
        CompoundTag nbt = new CompoundTag();
        createCap().saveNBTData(nbt);
        return nbt;
    }

    @Override
    public void deserializeNBT(CompoundTag nbt) {
        createCap().loadNBTData(nbt);
    }
}

Capability events:

public class SpiritCapabilityEvents {

    @SubscribeEvent
    public void onAttachCapabilitiesPlayer(AttachCapabilitiesEvent<Entity> event){
        if (event.getObject() instanceof Player) {
            if (!event.getObject().getCapability(SpiritCapabilityProvider.SPIRIT_CAP).isPresent()) {
                event.addCapability(new ResourceLocation(SinsOfDeath.MODID, "spiritcap"), new SpiritCapabilityProvider());
            }
        }
    }

    @SubscribeEvent
    public void onPlayerCloned(PlayerEvent.Clone event) {
        if(event.getOriginal().level.isClientSide)
            return;

        if(event.isWasDeath()) {
            LazyOptional<SpiritCapability> loNewCap = event.getPlayer().getCapability(SpiritCapabilityProvider.SPIRIT_CAP);
            // loOldCap is never present!
            LazyOptional<SpiritCapability> loOldCap = event.getOriginal().getCapability(SpiritCapabilityProvider.SPIRIT_CAP);
            loNewCap.ifPresent( newCap -> {
                loOldCap.ifPresent( oldCap -> {
                    newCap.copyFrom(oldCap);
                });
            });
        }
    }
}

Main class:

@Mod(SinsOfDeath.MODID)
public class SinsOfDeath
{
    // Directly reference a slf4j logger
    public static final String MODID = "sinsofdeath";
    private static final Logger LOGGER = LogUtils.getLogger();

    public SinsOfDeath()
    {
        // Register the setup method for modloading
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::onRegisterCapabilities);

    }

    private void setup(final FMLCommonSetupEvent event)
    {
        MinecraftForge.EVENT_BUS.register(new DeathEvent());
        MinecraftForge.EVENT_BUS.register(new CommandEvent());
        MinecraftForge.EVENT_BUS.register(new SpiritCapabilityEvents());
        Networking.registerMessages();
    }

    public void onRegisterCapabilities(RegisterCapabilitiesEvent event) {
        event.register(SpiritCapability.class);
    }
}

When setting capability data, I use the following code server-side:

// ep is ServerPlayer 
...
ep.getCapability(SpiritCapabilityProvider.SPIRIT_CAP).ifPresent(spiritDeath -> {
    spiritDeath.addDeath(finalDt, ep.deathTime);
});
...

Am I forgetting something?

Edited June 24, 20223 yr by ZigTheHedge
Solved

in PlayerEvent.Clone you need to call Player#reviveCaps before cloning the Capability and Player#invalidateCaps after cloning

Wow that's new! And it helped! Thanks!
And BTW: invalidateCaps isn't needed

Edited June 24, 20223 yr by ZigTheHedge