[Version 1.18.2, SOLVED] Custom status effect that changes the player's size, Part II

[LeeCrafts]

Hello,

I have been able to properly increase the player's hitbox size whenever that player gains a custom status effect (named "Big"). But, I have yet to increase the player's render size.

CMIIW, this is how it should work:

• Each (server) player should have its own capability that just stores a boolean, which I name isBig.
• isBig is true if a player has the Big status effect. I am unsure if I have to check--for every tick--if the player has the effect.
• Each player must send a packet to every other player's client. The packet stores the player's capability's provided NBT (which only contains a boolean, "isBig"). In other words, capability data must be synced across clients. 
  • Several events are needed for this: StartTracking, PlayerLoggedInEvent, PlayerRespawnEvent, and PlayerChangedDimensionEvent.
• Finally, using RenderPlayerEvent.Pre, each client-side player's capability is checked. If isBig == true, then that player's render size is increased.

 

Unfortunately, I have trouble executing this by code. (A lot of) relevant code is below:

// Capability interface
public interface IBig {
    void setBig(boolean isBig);
    boolean getBig();
    void sync(Big big, ServerPlayer player);
}

 

// Capability implementing the interface
public class Big implements IBig {
    private boolean isBig;
    public Big() {
        this.isBig = false;
    }

    @Override
    public void setBig(boolean isBig) {
        this.isBig = isBig;
    }

    @Override
    public boolean getBig() {
        return this.isBig;
    }

    @Override
    public void sync(Big big, ServerPlayer player) {
        // checks if player has the Big status effect
        big.setBig(player.getActiveEffectsMap() != null && player.hasEffect(ModEffects.BIG.get()));
      
        CompoundTag nbt = new CompoundTag();
        nbt.putBoolean("big", big.getBig());
        PacketHandler.INSTANCE.send(
                PacketDistributor.TRACKING_ENTITY_AND_SELF.noArg(),
                new ClientboundMobSizeUpdatePacket(nbt)
        );
    }
}

 

// Provider for the capability
public class BigProvider implements ICapabilitySerializable<CompoundTag> {

    private final Big big = new Big();
    private final LazyOptional<IBig> bigLazyOptional = LazyOptional.of(() -> big);

    @NotNull
    @Override
    public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
//        return bigLazyOptional.cast();
        return ModCapabilities.BIG_CAPABILITY.orEmpty(cap, bigLazyOptional);
    }

    @Override
    public CompoundTag serializeNBT() {
        if (ModCapabilities.BIG_CAPABILITY == null) {
            return new CompoundTag();
        }
        CompoundTag nbt = new CompoundTag();
        nbt.putBoolean("big", big.getBig());
        return nbt;
    }

    @Override
    public void deserializeNBT(CompoundTag nbt) {
        if (ModCapabilities.BIG_CAPABILITY != null) {
            big.setBig(nbt.getBoolean("big"));
        }
    }

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

 

public class ModCapabilities {
    // other capabilities...
    
    // instance of the Big capability
    public static Capability<IBig> BIG_CAPABILITY = CapabilityManager.get(new CapabilityToken<>(){});

}

 

// Events for registering and attaching capabilities
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID)
public class ModEvents {

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

    @SubscribeEvent
    public static void onAttachCapabilitiesEventBig(AttachCapabilitiesEvent<Entity> event) {
        if (event.getObject() instanceof Player && !event.getObject().getCommandSenderWorld().isClientSide) {
            BigProvider bigProvider = new BigProvider();
            event.addCapability(new ResourceLocation(ExampleMod.MOD_ID, "big"), bigProvider);
            event.addListener(bigProvider::invalidate);
        }
    }

}

 

// FMLCommonSetupEvent for initializing the packet handler
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
public class ModCommonEvents {
    @SubscribeEvent
    public static void commonSetup(FMLCommonSetupEvent event) {
        event.enqueueWork(PacketHandler::init);
    }
}

 

// The packet handler class itself
public class PacketHandler {
    private static final String PROTOCOL_VERSION = "1";

    public static SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(
            new ResourceLocation(ExampleMod.MOD_ID, "main"), () -> PROTOCOL_VERSION, PROTOCOL_VERSION::equals,
            PROTOCOL_VERSION::equals);

    private PacketHandler() {
    }

    public static void init() {
        int index = 0;
        INSTANCE.messageBuilder(ClientboundMobSizeUpdatePacket.class, index++, NetworkDirection.PLAY_TO_CLIENT)
                .encoder(ClientboundMobSizeUpdatePacket::encode).decoder(ClientboundMobSizeUpdatePacket::new)
                .consumer(ClientboundMobSizeUpdatePacket::handle).add();
    }

}

 

// Packet class
public class ClientboundMobSizeUpdatePacket {
    private CompoundTag nbt;
    public ClientboundMobSizeUpdatePacket(CompoundTag nbt) {
        this.nbt = nbt;
    }

    public ClientboundMobSizeUpdatePacket(FriendlyByteBuf buffer) {
        this(buffer.readNbt());
    }

    public void encode(FriendlyByteBuf buffer) {
        buffer.writeNbt(this.nbt);
    }

    public boolean handle(Supplier<NetworkEvent.Context> ctx) {
        final var success = new AtomicBoolean(false);
        ctx.get().enqueueWork(() -> {
            if (ctx.get().getDirection().getReceptionSide().isClient() && ctx.get().getDirection().getOriginationSide().isServer()) {
                // the player variable should be a client-side player whose capability is to be updated
                final LocalPlayer player = Minecraft.getInstance().player;
                DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> {
                    player.getCapability(ModCapabilities.BIG_CAPABILITY).ifPresent(iBig -> {
                        Big big = (Big) iBig;
                        big.setBig(new BigProvider().serializeNBT().getBoolean("big"));
                    });
                });
                success.set(true);
            }
        });
        ctx.get().setPacketHandled(success.get());
        return success.get();
    }
}

 

// Event handler for client-side players. This is where the render size change should happen.
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, value = Dist.CLIENT)
public class ModClientEvents {
    // must be client-side only
    @SubscribeEvent
    public static void big(RenderPlayerEvent.Pre event) {
        // Do I need to use Minecraft.getInstance() to get the player? Just wondering because we're dealing with the client side here.
//        Player player = event.getPlayer();
        final Player player = Minecraft.getInstance().level.getPlayerByUUID(event.getPlayer().getUUID());

        if (player != null) {
            player.getCapability(ModCapabilities.BIG_CAPABILITY).ifPresent(iBig -> {
                // Through some debugging, I have found out that this section never gets reached
              
                Big big = (Big) iBig;
                if (big.getBig()) {
                    event.getPoseStack().scale(8.0F, 2.0F, 8.0F);
                }
            });
        }
    }
}

 

// Event handlers for server-side players

// I must set the value to Dist.DEDICATED_SERVER otherwise a crash will occur
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE, value = Dist.DEDICATED_SERVER)
public class ForgeCommonEvents {
    
    @SubscribeEvent
    public static void startTracking(PlayerEvent.StartTracking event) {
        Player player = (Player) event.getTarget();
        ServerPlayer target = (ServerPlayer) event.getPlayer();
        if (!player.level.isClientSide()) {
            player.getCapability(ModCapabilities.BIG_CAPABILITY).ifPresent(iBig -> {
                Big big = (Big) iBig;
              
                // checks if player has the Big status effect
                big.setBig(player.getActiveEffectsMap() != null && player.hasEffect(ModEffects.BIG.get()));
              
                CompoundTag nbt = new CompoundTag();
                nbt.putBoolean("big", big.getBig());
                PacketHandler.INSTANCE.send(
                        PacketDistributor.PLAYER.with(() -> target),
                        new ClientboundMobSizeUpdatePacket(nbt)
                );
            });
        }
    }

    @SubscribeEvent
    public static void playerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
        ServerPlayer player = (ServerPlayer) event.getPlayer();
        if (!player.level.isClientSide()) {
            player.getCapability(ModCapabilities.BIG_CAPABILITY).ifPresent(iBig -> {
                Big big = (Big) iBig;
                iBig.sync(big, player);
            });
        }
    }

    @SubscribeEvent
    public static void playerRespawn(PlayerEvent.PlayerRespawnEvent event) {
        ServerPlayer player = (ServerPlayer) event.getPlayer();
        if (!player.level.isClientSide()) {
            player.getCapability(ModCapabilities.BIG_CAPABILITY).ifPresent(iBig -> {
                Big big = (Big) iBig;
                iBig.sync(big, player);
            });
        }
    }

    @SubscribeEvent
    public static void playerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
        ServerPlayer player = (ServerPlayer) event.getPlayer();
        if (!player.level.isClientSide()) {
            player.getCapability(ModCapabilities.BIG_CAPABILITY).ifPresent(iBig -> {
                Big big = (Big) iBig;
                iBig.sync(big, player);
            });
        }
    }

}

 

When the player gets the Big status effect, it does not grow like it should. As indicated by the last section of code, the client-side player's capability is never present for some reason. Is my logic incorrect? I appreciate the help, thank you in advance.

Edited Saturday at 06:13 AM by LeeCrafts

[diesieben07]

• If you expect your capability to be always present, why are you using ifPresent?

• 47 minutes ago, LeeCrafts said:

  final Player player = Minecraft.getInstance().level.getPlayerByUUID(event.getPlayer().getUUID());

  This achieves nothing except waste CPU cycles.

• 48 minutes ago, LeeCrafts said:

  final var success = new AtomicBoolean(false);

  What even? Why is this an AtomicBoolean?

• 48 minutes ago, LeeCrafts said:

  big.setBig(new BigProvider().serializeNBT().getBoolean("big"));

  You completely ignore the data that was sent with your packet. Instead you create a new provider, which will have the default values, serialize it and use the serialized data... somehow? Why?

• Why do you even have the capability in the first place if all it does is duplicate the "is the status effect present" info? Just check for the effect directly.

[LeeCrafts]

Thank you for the reply, I'll be testing the the needed changes.

Meanwhile...I don't know how I didn't find this out earlier, but the server player events (StartTracking, PlayerLoggedInEvent, PlayerRespawnEvent, and PlayerChangedDimensionEvent) never actually fire. Is it because the value argument in EventBusSubscriber is Dist.DEDICATED_SERVER? I have been testing my game via the ./gradlew runClient command, and I wonder if that's the reason.

Anyways, I removed the Dist.DEDICATED_SERVER part and the events do fire...but the game crashes right afterwards. The error message says:

java.lang.NullPointerException: Cannot invoke "net.minecraft.world.entity.Entity.getCommandSenderWorld()" because "entity" is null

...even when I check if event.getPlayer() is not null.

How do I solve this?

Edited Saturday at 05:25 AM by LeeCrafts

[diesieben07]

14 hours ago, LeeCrafts said:

Is it because the value argument in EventBusSubscriber is Dist.DEDICATED_SERVER? I have been testing my game via the ./gradlew runClient command

runClient starts a client. Which is not a dedicated server. To check for logical server, use Level#isClient: https://mcforge.readthedocs.io/en/latest/concepts/sides/.

Before we continue debugging your syncing code, please answer my question regarding why you have the capability.

[LeeCrafts]

The reason I'm using a capability is because I just want to learn how to sync capability data across clients in general. I feel like that's an important skill to learn.

To answer your other questions:

On 5/10/2022 at 3:36 AM, diesieben07 said:

If you expect your capability to be always present, why are you using ifPresent? This achieves nothing except waste CPU cycles.

In that case, I guess I should just use orElse() instead. That is, player.getCapability(ModCapabilities.BIG_CAPABILITY).orElse(new Big()). I am not entirely sure if this would be sufficient, though.

On 5/10/2022 at 3:36 AM, diesieben07 said:

What even? Why is this an AtomicBoolean?

Haha, I was following a tutorial on YouTube, and I guess using an AtomicBoolean would be a "safe" option.

On 5/10/2022 at 3:36 AM, diesieben07 said:

You completely ignore the data that was sent with your packet. Instead you create a new provider, which will have the default values, serialize it and use the serialized data... somehow? Why?

Perhaps I should change that line of code to big.setBig(nbt.getBoolean("big")).

[Luis_ST]

24 minutes ago, LeeCrafts said:

In that case, I guess I should just use orElse() instead. That is, player.getCapability(ModCapabilities.BIG_CAPABILITY).orElse(new Big()). I am not entirely sure if this would be sufficient, though.

you should use #orElseThrow or #ifPresent, since the Capability should/is always present

Edited Wednesday at 04:09 PM by Luis_ST

[diesieben07]

1 hour ago, LeeCrafts said:

The reason I'm using a capability is because I just want to learn how to sync capability data across clients in general. I feel like that's an important skill to learn.

I mean, sure, but a capability is the wrong tool here.

1 hour ago, LeeCrafts said:

In that case, I guess I should just use orElse() instead. That is, player.getCapability(ModCapabilities.BIG_CAPABILITY).orElse(new Big()). I am not entirely sure if this would be sufficient, though.

orElse still assumes "oh, this could be absent sometimes, that's OK and normal". Is it really OK and normal for your capability to randomly be missing? If not, orElseThrow is the only valid option. If yes, handle the absent case properly.

1 hour ago, LeeCrafts said:

Haha, I was following a tutorial on YouTube, and I guess using an AtomicBoolean would be a "safe" option.

I don't know why you used it here at all.

1 hour ago, LeeCrafts said:

Perhaps I should change that line of code to big.setBig(nbt.getBoolean("big")).

I guess so, yes. Or, you know, use the deserialization methods you have already written.

[LeeCrafts]

Solved. As diesieben07 mentioned, capabilities are not needed. So I no longer used them. My packet now stores a player's UUID and whether that player has the "big" effect. A client has an internal hash map to store the relevant data respective to each player.

Below is all the code I needed:

// FMLCommonSetupEvent for initializing the packet handler
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.MOD)
public class ModCommonEvents {
    @SubscribeEvent
    public static void commonSetup(FMLCommonSetupEvent event) {
        event.enqueueWork(PacketHandler::init);
    }
}

 

// The packet handler class itself
public class PacketHandler {

    private static final String PROTOCOL_VERSION = "1";

    public static SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(
            new ResourceLocation(ExampleMod.MOD_ID, "main"),
            () -> PROTOCOL_VERSION, PROTOCOL_VERSION::equals,
            PROTOCOL_VERSION::equals
    );

    private PacketHandler() {}

    public static void init() {
        int index = 0;
        INSTANCE.messageBuilder(ClientboundMobSizeUpdatePacket.class, index++, NetworkDirection.PLAY_TO_CLIENT)
                .encoder(ClientboundMobSizeUpdatePacket::encode).decoder(ClientboundMobSizeUpdatePacket::new)
                .consumer(ClientboundMobSizeUpdatePacket::handle).add();
    }

}

 

// Packet class
public class ClientboundMobSizeUpdatePacket {

    private final UUID uuid;
    private final boolean isBig;

    public ClientboundMobSizeUpdatePacket(UUID uuid, boolean isBig) {
        this.uuid = uuid;
        this.isBig = isBig;
    }

    public ClientboundMobSizeUpdatePacket(FriendlyByteBuf buffer) {
        this(buffer.readUUID(), buffer.readBoolean());
    }

    public void encode(FriendlyByteBuf buffer) {
        buffer.writeUUID(uuid);
        buffer.writeBoolean(isBig);
    }

    public void handle(Supplier<NetworkEvent.Context> ctx) {
        ctx.get().enqueueWork(() -> {
            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> ClientboundMobSizeUpdatePacketHandler.handlePacket(this.uuid, this.isBig));
        });
        ctx.get().setPacketHandled(true);
    }

}

 

// Client (mob size update) packet handler class
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, value = Dist.CLIENT)
public class ClientboundMobSizeUpdatePacketHandler {

    static HashMap<UUID, Boolean> trackedPlayersBigEffects;

    public static void handlePacket(UUID uuid, boolean isBig) {
        // When the client receives the packet from a player, it stores that player's UUID and "big" status into its internal hash map.
        initializeIfNull();
        trackedPlayersBigEffects.put(uuid, isBig);
    }

    // This is where the render size change happens.
    @SubscribeEvent
    public static void big(RenderPlayerEvent.Pre event) {
        Player player = event.getPlayer();
        if (player != null) {
            initializeIfNull();
            boolean isBig = trackedPlayersBigEffects.getOrDefault(player.getUUID(), false);
            isBig = isBig || (player.getActiveEffectsMap() != null && player.hasEffect(ModEffects.BIG.get()));
            if (isBig) event.getPoseStack().scale(8.0F, 2.0F, 8.0F);
        }
    }

    private static void initializeIfNull() {
        if (trackedPlayersBigEffects == null) trackedPlayersBigEffects = new HashMap<>();
    }

}

 

// Server-side event. The player sends packets to any other player tracking it.
@Mod.EventBusSubscriber(modid = ExampleMod.MOD_ID, bus = Mod.EventBusSubscriber.Bus.FORGE, value = Dist.DEDICATED_SERVER)
public class ForgeCommonEvents {

    @SubscribeEvent
    public static void startTracking(PlayerEvent.StartTracking event) {

        // the (player) entity whose "big" status is being tracked
        Entity entity = event.getTarget();

        // the player tracking the player's "big" status will be sent packets
        ServerPlayer target = (ServerPlayer) event.getPlayer();

        if (entity instanceof Player player && !player.level.isClientSide()) {
            boolean isBig = player.getActiveEffectsMap() != null && player.hasEffect(ModEffects.BIG.get());
            PacketHandler.INSTANCE.send(
                    PacketDistributor.PLAYER.with(() -> target),
                    new ClientboundMobSizeUpdatePacket(player.getUUID(), isBig)
            );
        }
    }

}

 

// Custom status effect class. addAttributeModifiers and removeAttributeModifiers are overridden because we want a player to send a packet whenever it gains or loses the custom status effect.
public class BigEffect extends MobEffect {

    public BigEffect(MobEffectCategory mobEffectCategory, int color) {
        super(mobEffectCategory, color);
    }

    @Override
    public void applyEffectTick(LivingEntity pLivingEntity, int pAmplifier) {
        // see my previous post
        pLivingEntity.setBoundingBox(new AABB(pLivingEntity.getX()+2.5, pLivingEntity.getY()+3.6, pLivingEntity.getZ()+2.5, pLivingEntity.getX()-2.5, pLivingEntity.getY(), pLivingEntity.getZ()-2.5));
        super.applyEffectTick(pLivingEntity, pAmplifier);
    }

    @Override
    public boolean isDurationEffectTick(int pDuration, int pAmplifier) {
        return true;
    }

    @Override
    public void addAttributeModifiers(LivingEntity pLivingEntity, AttributeMap pAttributeMap, int pAmplifier) {
        if (pLivingEntity instanceof Player player) {
            PacketHandler.INSTANCE.send(
                    PacketDistributor.TRACKING_ENTITY_AND_SELF.with(() -> player),
                    new ClientboundMobSizeUpdatePacket(player.getUUID(), true)
            );
        }
        super.addAttributeModifiers(pLivingEntity, pAttributeMap, pAmplifier);
    }

    @Override
    public void removeAttributeModifiers(LivingEntity pLivingEntity, AttributeMap pAttributeMap, int pAmplifier) {
        if (pLivingEntity instanceof Player player) {
            PacketHandler.INSTANCE.send(
                    PacketDistributor.TRACKING_ENTITY_AND_SELF.with(() -> player),
                    new ClientboundMobSizeUpdatePacket(player.getUUID(), false)
            );
        }
        super.removeAttributeModifiers(pLivingEntity, pAttributeMap, pAmplifier);
    }

}

 

It works, but I am not sure if it is the most graceful solution. That is, regarding the ClientboundMobSizeUpdatePacketHandler class. I feel like there is a less crude way than just using a HashMap and getting players from the client by their UUID's. If there is, please let me know.

Edited Saturday at 07:07 AM by LeeCrafts

[diesieben07]

Your HashMap is not needed. Your packet is also not needed.

The game already has a place to store active effects: LivingEntity#hasEffect and friends. These are not populated on the client except for the player itself. However the game already has a way to sync them to the client: ClientboundUpdateMobEffectPacket and ClientboundRemoveMobEffectPacket. You can use them for other players, too. No need for a custom place to store the effect and no need for a custom packet. Then you can just use hasEffect and friends on the client.

[diesieben07]

Having said the above: A less crude way to store this data on the client, if you were using extra data (not something built in) would be indeed a capability. But you'd only have that, if you need it on the server, too - which you don't in this case.

[LeeCrafts]

Good to know. Then would I still need the my packet handler class? If so, I am having trouble in the init() method. When I insert ClientboundUpdateMobEffectPacket::handle (same for ClientboundRemoveMobEffectPacket) as the argument for consumer(), I get an error saying "Reference to 'handle' is ambiguous, both 'handle(ClientGamePacketListener)' and 'handle(T)' match". I understand what this error is, but I do not know how to fix it. 

And when I tried to run the code, I get a compiler error saying "incompatible types: Supplier<Context> cannot be converted to ClientGamePacketListener)". How would I solve this if ClientboundUpdateMobEffectPacket::handle takes in a ClientGamePacketListener argument instead of a Supplier<Context> argument?

// The packet handler class itself
public class PacketHandler {

    private static final String PROTOCOL_VERSION = "1";

    public static SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(
            new ResourceLocation(ExampleMod.MOD_ID, "main"),
            () -> PROTOCOL_VERSION, PROTOCOL_VERSION::equals,
            PROTOCOL_VERSION::equals
    );

    private PacketHandler() {}

    public static void init() {
        int index = 0;
        // "Reference to 'handle' is ambiguous, both 'handle(ClientGamePacketListener)' and 'handle(T)' match"
        INSTANCE.messageBuilder(ClientboundUpdateMobEffectPacket.class, index++, NetworkDirection.PLAY_TO_CLIENT)
                .encoder(ClientboundUpdateMobEffectPacket::write).decoder(ClientboundUpdateMobEffectPacket::new)
                .consumer(ClientboundUpdateMobEffectPacket::handle).add();
        INSTANCE.messageBuilder(ClientboundRemoveMobEffectPacket.class, index++, NetworkDirection.PLAY_TO_CLIENT)
                .encoder(ClientboundRemoveMobEffectPacket::write).decoder(ClientboundRemoveMobEffectPacket::new)
                .consumer(ClientboundRemoveMobEffectPacket::handle).add();
    }

}

 

On the other hand, if I do not need this packet handler class, how else would I send packets? The only way I know is calling PacketHandler.INSTANCE.send() (and Level::sendPacketToServer, but this problem is about clientbound packets, not serverbound).