1.20.1 Custom Container not working as intended [1.20.1]

[EveryBlu]

I have been working on a complex block for a mod I'm working on. This block is really unfinished right now, but there is this strange bug that is hindering progress.

Basically, this block has a single slot where you put a specific item, then there are three "buttons" on the right like the Enchantment Table. Later on these buttons will have a special purpose so don't worry about them, but right now these buttons just increment a new property on the player as long as they have xp levels.

The bug is that whenever you click on one of the three buttons, the items you put in are supposed to decrement, but when you take them out or you reopen the block's gui, the item stack mysteriously "resets", meaning that all the items that were consumed are present again.

Here is the Block Entity class (do realize that I am developing this mod in IntelliJ IDEA 2024.1.4 Community Edition):

package everyblu.ars_mythos.common.block.tiles;

import com.github.alexthe666.iceandfire.item.IafItemRegistry;
import everyblu.ars_mythos.client.menus.ArcaneScholarsAnalysisMenu;
import everyblu.ars_mythos.common.block.ArcaneScholarsBlock;
import everyblu.ars_mythos.common.block.ArsMythosBlockStateProperties;
import everyblu.ars_mythos.common.registry.ArsMythosObjectRegistry;
import net.minecraft.core.BlockPos;
import net.minecraft.core.Direction;
import net.minecraft.core.NonNullList;
import net.minecraft.nbt.CompoundTag;
import net.minecraft.network.chat.Component;
import net.minecraft.world.*;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.block.entity.BlockEntity;
import net.minecraft.world.level.block.state.BlockState;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import software.bernie.geckolib.animatable.GeoBlockEntity;
import software.bernie.geckolib.core.animatable.instance.AnimatableInstanceCache;
import software.bernie.geckolib.core.animation.AnimatableManager;
import software.bernie.geckolib.core.animation.AnimationController;
import software.bernie.geckolib.core.object.PlayState;
import software.bernie.geckolib.util.GeckoLibUtil;

public class ArcaneScholarsTile extends BlockEntity implements GeoBlockEntity, WorldlyContainer, MenuProvider {
    public final String variant;
    private final NonNullList<ItemStack> items = NonNullList.withSize(1, ItemStack.EMPTY);

    public ArcaneScholarsTile(BlockPos pPos, BlockState pBlockState) {
        super(ArsMythosObjectRegistry.NEW_ARCANE_SCHOLARS_TILE.get(), pPos, pBlockState);
        this.variant = switch (pBlockState.getValue(ArsMythosBlockStateProperties.ARCANE_SCHOLARS_VARIANT)) {
            case 1 -> "fire";
            case 2 -> "ice";
            default -> "lightning";
        };
    }

    @Override
    public void load(@NotNull CompoundTag tag) {
        super.load(tag);
        ContainerHelper.loadAllItems(tag, this.items);
        System.out.println("loaded");
    }

    @Override
    protected void saveAdditional(@NotNull CompoundTag tag) {
        if (this.level == null) return;
        ContainerHelper.saveAllItems(tag, this.items);
        super.saveAdditional(tag);
    }

    private ArcaneScholarsTile getFootPart() {
        if (this.level == null) return this;
        BlockEntity nextEntity = this.level.getBlockEntity(
                this.getBlockPos().relative(this.getBlockState().getValue(ArcaneScholarsBlock.FACING)));

        if (nextEntity instanceof ArcaneScholarsTile arcaneScholarsTile) return arcaneScholarsTile;
        return this;
    }

    AnimationController<ArcaneScholarsTile> controller;
    AnimatableInstanceCache factory = GeckoLibUtil.createInstanceCache(this);

    @Override
    public void registerControllers(AnimatableManager.ControllerRegistrar controllerRegistrar) {
        this.controller = new AnimationController<>(this, "controller", 1, (state) -> PlayState.CONTINUE);
        controllerRegistrar.add(this.controller);
    }

    @Override
    public AnimatableInstanceCache getAnimatableInstanceCache() {
        return this.factory;
    }

    @Override
    public @NotNull Component getDisplayName() {
        return Component.literal("Arcane Scholar's Table");
    }

    @Nullable
    @Override
    public AbstractContainerMenu createMenu(int pContainerId, @NotNull Inventory pPlayerInventory, @NotNull Player pPlayer) {
        BlockEntity entity = this.getFootPart();
        return new ArcaneScholarsAnalysisMenu(pContainerId, pPlayerInventory, entity);
    }

    @Override
    public int @NotNull [] getSlotsForFace(@NotNull Direction pSide) {
        return new int[0];
    }

    @Override
    public boolean canPlaceItemThroughFace(int pIndex, @NotNull ItemStack pItemStack, @Nullable Direction pDirection) {
        return pDirection == Direction.UP && pItemStack.is(IafItemRegistry.MANUSCRIPT.get());
    }

    @Override
    public boolean canTakeItemThroughFace(int pIndex, @NotNull ItemStack pStack, @NotNull Direction pDirection) {
        return false;
    }

    @Override
    public int getContainerSize() {
        return 1;
    }

    @Override
    public boolean isEmpty() {
        return this.items.get(0).isEmpty();
    }

    @Override
    public @NotNull ItemStack getItem(int pSlot) {
        return this.items.get(0);
    }

    @Override
    public @NotNull ItemStack removeItem(int pSlot, int pAmount) {
        ItemStack stack = ContainerHelper.removeItem(this.items, pSlot, pAmount);
        System.out.println(this.items.get(0).getCount());
        return stack;
    }

    @Override
    public @NotNull ItemStack removeItemNoUpdate(int pSlot) {
        return ContainerHelper.takeItem(this.items, pSlot);
    }

    @Override
    public void setItem(int pSlot, @NotNull ItemStack pStack) {
        this.items.set(pSlot, pStack);
        if (pStack.getCount() > this.getMaxStackSize()) {
            pStack.setCount(this.getMaxStackSize());
        }

        if (!pStack.isEmpty()) this.setChanged();
    }

    @Override
    public boolean stillValid(@NotNull Player pPlayer) {
        return Container.stillValidBlockEntity(this, pPlayer);
    }

    @Override
    public void clearContent() {
        this.items.clear();
    }
}

Here is the AbstractContainerMenu:

package everyblu.ars_mythos.client.menus;

import everyblu.ars_mythos.client.ArsMythosClientRegistry;
import everyblu.ars_mythos.common.block.tiles.ArcaneScholarsTile;
import everyblu.ars_mythos.common.capabilities.ArcaneResearchDataProvider;
import everyblu.ars_mythos.common.helper.ContainerUtils;
import everyblu.ars_mythos.common.registry.ArsMythosObjectRegistry;
import net.minecraft.network.FriendlyByteBuf;
import net.minecraft.sounds.SoundEvents;
import net.minecraft.world.entity.player.Inventory;
import net.minecraft.world.entity.player.Player;
import net.minecraft.world.inventory.AbstractContainerMenu;
import net.minecraft.world.inventory.ContainerLevelAccess;
import net.minecraft.world.inventory.Slot;
import net.minecraft.world.item.ItemStack;
import net.minecraft.world.level.block.entity.BlockEntity;
import org.jetbrains.annotations.NotNull;

public class ArcaneScholarsAnalysisMenu extends AbstractContainerMenu {
    private final ArcaneScholarsTile tile;

    public ArcaneScholarsAnalysisMenu(int index, Inventory playerInventory, FriendlyByteBuf data) {
        this(index, playerInventory, playerInventory.player.level().getBlockEntity(data.readBlockPos()));
    }

    public ArcaneScholarsAnalysisMenu(int index, Inventory playerInventory, BlockEntity entity) {
        super(ArsMythosClientRegistry.AS_ANALYSIS.get(), index);
        this.tile = ((ArcaneScholarsTile) entity);

        ContainerUtils.addPlayerInventoryTo(this, playerInventory);
        ContainerUtils.addPlayerHotBarTo(this, playerInventory);

        this.addSlot(new Slot(this.tile, 0, 15, 47));
    }

    @Override
    public boolean clickMenuButton(@NotNull Player player, int pId) {
        if (this.tile.isEmpty()) return false;
        if (player.experienceLevel < 1) return false;

        player.getCapability(ArcaneResearchDataProvider.RESEARCH_DATA_KEY).ifPresent(research ->
                research.addOrSubResearch(research.getFireResearch(), 1, 0, 0, true));
        player.playSound(SoundEvents.VILLAGER_WORK_CARTOGRAPHER);
        if (!player.getAbilities().instabuild) {
            this.tile.removeItem(0, 1);
            player.experienceLevel--;
        }

        return super.clickMenuButton(player, pId);
    }

    @Override
    public @NotNull ItemStack quickMoveStack(@NotNull Player pPlayer, int pIndex) {
        return ContainerUtils.quickMoveStack(pPlayer, pIndex, this.slots, this, (data) -> this.moveItemStackTo(data.getLeft(), data.getMiddle(), data.getRight(), false),
                1);
    }

    @Override
    public boolean stillValid(@NotNull Player pPlayer) {
        return stillValid(
                ContainerLevelAccess.create(pPlayer.level(), this.tile.getBlockPos()),
                pPlayer, ArsMythosObjectRegistry.ARCANE_SCHOLARS_TABLE_FIRE.get());
    }

    public boolean manuscriptsEmpty() {
        return this.tile.isEmpty();
    }
}

And finally, here is the AbstractContainerScreen (if needed):

package everyblu.ars_mythos.client.screens;

import com.mojang.blaze3d.systems.RenderSystem;
import everyblu.ars_mythos.ArsMythos;
import everyblu.ars_mythos.client.menus.ArcaneScholarsAnalysisMenu;
import everyblu.ars_mythos.common.capabilities.ArcaneResearchDataProvider;
import net.minecraft.client.gui.GuiGraphics;
import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
import net.minecraft.client.renderer.GameRenderer;
import net.minecraft.network.chat.Component;
import net.minecraft.resources.ResourceLocation;
import net.minecraft.world.entity.player.Inventory;
import org.jetbrains.annotations.NotNull;

public class ArcaneScholarsAnalysisScreen extends AbstractContainerScreen<ArcaneScholarsAnalysisMenu> {
    public static final ResourceLocation GUI_TEXTURE = ArsMythos.prefix("textures/gui/arcane_scholars_table_analysis.png");

    public ArcaneScholarsAnalysisScreen(ArcaneScholarsAnalysisMenu pMenu, Inventory pPlayerInventory, Component pTitle) {
        super(pMenu, pPlayerInventory, pTitle);
    }

    @Override
    @SuppressWarnings("all")
    public boolean mouseClicked(double pMouseX, double pMouseY, int pButton) {
        int x = (this.width - this.imageWidth) / 2;
        int y = (this.height - this.imageHeight) / 2;

        for(int k = 0; k < 3; ++k) {
            double d0 = pMouseX - (double)(x + 60);
            double d1 = pMouseY - (double)(y + 14 + 19 * k);
            if (d0 >= 0.0D && d1 >= 0.0D && d0 < 108.0D && d1 < 19.0D && this.menu.clickMenuButton(this.minecraft.player, k)) {
                this.minecraft.gameMode.handleInventoryButtonClick((this.menu).containerId, k);

                return true;
            }
        }

        return super.mouseClicked(pMouseX, pMouseY, pButton);
    }

    @Override
    @SuppressWarnings("all")
    protected void renderBg(@NotNull GuiGraphics guiGraphics, float pPartialTick, int pMouseX, int pMouseY) {
        RenderSystem.setShader(GameRenderer::getPositionTexShader);
        RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
        RenderSystem.setShaderTexture(0, GUI_TEXTURE);

        int x = (this.width - this.imageWidth) / 2;
        int y = (this.height - this.imageHeight) / 2;
        guiGraphics.blit(GUI_TEXTURE, x, y, 0, 0, this.imageWidth, this.imageHeight);

        this.minecraft.player.getCapability(ArcaneResearchDataProvider.RESEARCH_DATA_KEY).ifPresent(research -> guiGraphics.drawString(
                this.minecraft.font, research.getFireResearch().getLeft().toString(), x + 160, y + 4, 255));

        guiGraphics.drawString(this.minecraft.font, String.valueOf(this.minecraft.player.experienceLevel), x + 61, y + 74, 255);

        for (int k = 0; k < 3; ++k) {
            if (this.menu.manuscriptsEmpty() || this.minecraft.player.experienceLevel < 1) {
                guiGraphics.blit(GUI_TEXTURE, x + 60, y + 14 + (19 * k), 0, 185, 108, 19);
                continue;
            }

            guiGraphics.blit(GUI_TEXTURE, x + 60, y + 14 + (19 * k), 0, 166, 108, 19);

            double d0 = pMouseX - (double)(x + 60);
            double d1 = pMouseY - (double)(y + 14 + 19 * k);
            if (d0 >= 0.0D && d1 >= 0.0D && d0 < 108.0D && d1 < 19.0D) {
                guiGraphics.blit(GUI_TEXTURE, x + 60, y + 14 + (19 * k), 0, 204, 108, 19);
            }
        }
    }

    @Override
    public void render(@NotNull GuiGraphics guiGraphics, int mouseX, int mouseY, float delta) {
        renderBackground(guiGraphics);
        super.render(guiGraphics, mouseX, mouseY, delta);
        renderTooltip(guiGraphics, mouseX, mouseY);
    }
}

Any help is appreciated.

Edited November 19 by EveryBlu