I have created a fluid capability on the block entity. Now I want to display this liquid in the GUI. (Type and amount of liquid) But I have no idea how to synchronize this capability in container or screen.

Edited February 28, 20223 yr by reasure
solved! thanks for helping!

there are two ways:

1. you use a custom Network Packet and sync the data via a SimpleChannel (doc). whenever the data changes
2. override BlockEntity#getUpdateTag and retrun a CompoundTag with the data to sync,
   override BlockEntity#handleUpdateTag to handle the data sync on client. whenever the data changes
   you need to call BlockEntity#setChanged

choose the way you prefer

Edited February 23, 20223 yr by Luis_ST

14 hours ago, Luis_ST said:

there are two ways:

1. you use a custom Network Packet and sync the data via a SimpleChannel (doc). whenever the data changes
2. override BlockEntity#getUpdateTag and retrun a CompoundTag with the data to sync,
   override BlockEntity#handleUpdateTag to handle the data sync on client. whenever the data changes
   you need to call BlockEntity#setChanged

choose the way you prefer

I choose 2nd.
And like this?

MyBlockEntity

    private final FluidTank fluidTank = createFluidTank();
    private final LazyOptional<IFluidHandler> fluidHandler = LazyOptional.of(() -> fluidTank); 

    ...

    public void loadClient(CompoundTag tag) {
        if (tag.contains("Fluid")) {
            fluidTank.readFromNBT(tag.getCompound("Fluid"));
        }
    }

    public void saveClient(CompoundTag tag) {
        CompoundTag fluid = new CompoundTag();
        fluidTank.writeToNBT(fluid);
        tag.put("Fluid", fluid);
    }

    @NotNull
    @Override
    public CompoundTag getUpdateTag() {
        CompoundTag tag = super.getUpdateTag();
        saveClient(tag);
        return tag;
    }

    @Override
    public void handleUpdateTag(CompoundTag tag) {
        if (tag != null) {
            loadClient(tag);
        }
    }

    ...

    private FluidTank createFluidTank() {
        return new FluidTank(FLUID_CAPACITY, (fluid -> fluid.getFluid().is(FluidTags.LAVA))) {
            @Override
            protected void onContentsChanged() {
                setChanged();
            }
        };
    }

    @Override
    public <T> LazyOptional<T> getCapability(@NotNull Capability<T> cap, @Nullable Direction side) {
        if (cap == CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY) {
            return fluidHandler.cast();
        } else {
            return super.getCapability(cap, side);
        }
    }

And MyContainerMenu

    public FluidStack getFluid() {
        return blockEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY).map(f -> f.getFluidInTank(0).copy()).orElse(null);
    }

And In Screen:

	FluidStack fluid = menu.getFluid()

The values are out of sync.

Edited February 24, 20223 yr by reasure
The values ​​are out of sync.

In the mcjty tutorial I saw, inventory was synchronized using slots and energy using data slots. But what about fluid?

Ok, Thank you.

2 hours ago, diesieben07 said:

You probably need a custom packet if you want to synchronize it in the Menu.

Sorry to keep asking basic questions.

More specifically, after creating a packet from the server to the client, should I send this packet in sendAllDataToRemoted() of the Menu class?

Edited February 25, 20223 yr by reasure

send the data whenever the data changed

Synchronization from server to client was successful.
However, when I reconnected to the world, it was out of sync. (It says the fluid is empty.)
What's wrong?

(If the fluid changes again, it will resynchronize.)

In MyBlockEntity.class

    @Override
    public void setChanged() {
        super.setChanged();
        onFluidChanged();
    }

    private void onFluidChanged() {
        if (level != null) {
            PacketHandler.INSTANCE.send(PacketDistributor.TRACKING_CHUNK.with(() -> level.getChunkAt(worldPosition)),
                    new FluidUpdatePacket(worldPosition, fluidTank.getFluid()));
        }
    }

@Override
    public void load(CompoundTag tag) {
        ...
        if (tag.contains("Fluid")) {
            fluidTank.readFromNBT(tag.getCompound("Fluid"));
        }
        super.load(tag);
        onFluidChanged();
    }

Edited February 26, 20223 yr by reasure

It seems to have been solved by rewriting the code from scratch. thank you!
Is it correct to do this?
If this method is correct, I will post the code for other people to refer to as well.
(For other parts, refer to mcjty's block entity and container tutorial.)
there's a bug again. Real-time update doesn't work.
Should the block entity also send packets?

(Container Class)

public class LavaGeneratorMenu extends AbstractContainerMenu {
    private final BlockEntity blockEntity;
    private final ContainerLevelAccess access;
    private final IItemHandler playerInventory;
    private FluidStack fluid;
    private final Player player;

    public LavaGeneratorMenu(int windowId, Inventory playerInv, BlockPos pos) {
        super(ModMenuTypes.LAVA_GENERATOR_CONTAINER.get(), windowId);
        this.playerInventory = new InvWrapper(playerInv);
        this.access = ContainerLevelAccess.create(playerInv.player.level, pos);
        this.player = playerInv.player;
        this.fluid = FluidStack.EMPTY;
        ...
    }

    public FluidStack getFluid() {
        return blockEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY).map(f -> f.getFluidInTank(0)).orElse(FluidStack.EMPTY);
    }

    @Override
    public boolean stillValid(@NotNull Player player) {
        return stillValid(access, player, ModBlocks.LAVA_GENERATOR.get());
    }
  
    @Override
    public void broadcastChanges() {
        super.broadcastChanges();
        if (player instanceof ServerPlayer sp) {
            FluidStack newFluid = getFluid();
            if (fluid.getAmount() != newFluid.getAmount() || !fluid.isFluidEqual(newFluid)) {
                PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> sp),
                        new FluidUpdatePacket(blockEntity.getBlockPos(), newFluid));
                this.fluid = newFluid;
            }
        }
    }

    @Override
    public void sendAllDataToRemote() {
        super.sendAllDataToRemote();
        if (player instanceof ServerPlayer sp) {
            PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> sp),
                    new FluidUpdatePacket(blockEntity.getBlockPos(), getFluid()));
        }
    }
}

(FluidUpdatePacket)

public class FluidUpdatePacket {
    public final BlockPos bePos;
    public final FluidStack fluid;

    public FluidUpdatePacket(BlockPos pos, FluidStack fluid) {
        this.bePos = pos;
        this.fluid = fluid;
    }

    public void encode(FriendlyByteBuf buffer) {
        buffer.writeBlockPos(bePos);
        buffer.writeFluidStack(fluid);
    }

    public static FluidUpdatePacket decode(FriendlyByteBuf buffer) {
        return new FluidUpdatePacket(buffer.readBlockPos(), buffer.readFluidStack());
    }

    public static void handle(FluidUpdatePacket msg, Supplier<NetworkEvent.Context> ctx) {
        AtomicBoolean success = new AtomicBoolean(false);
        ctx.get().enqueueWork(() -> {
            DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> success.set(ClientAccess.updateFluid(msg.bePos, msg.fluid)));
        });
        ctx.get().setPacketHandled(success.get());
    }
}

(ClientAccess (needed in Packet))

public class ClientAccess {
    public static boolean updateFluid(BlockPos pos, FluidStack fluid) {
        AtomicBoolean success = new AtomicBoolean(false);
        if (Minecraft.getInstance().level != null) {
            final BlockEntity blockEntity = Minecraft.getInstance().level.getBlockEntity(pos);
            if (blockEntity != null) {
                blockEntity.getCapability(CapabilityFluidHandler.FLUID_HANDLER_CAPABILITY).ifPresent(h -> {
                    if (h instanceof FluidTank tank) {
                        tank.setFluid(fluid);
                        success.set(true);
                    }
                });
            }
        }
        return success.get();
    }
}

Edit) I removed the "if (fluid.getAmount() != newFluid.getAmount() || !fluid.isFluidEqual(newFluid)) {" which is part of the container class and synchronized it unconditionally, and it worked fine.

Edited February 27, 20223 yr by reasure
there's a bug again. Real-time update doesn't work.

In Container class, I change "this.fluid = newFluid;" -> "this.fluid = newFluid.copy();" And It works correctly.

And I wonder if I should use fluid.copy() in Packet as well.

1 hour ago, reasure said:

Should the block entity also send packets?

if you only change the Capability while the Menu is open, then no