(SOLVED) [1.16.4] Saving Block data doesn't work with TileEntity, but does when Container uses the TileEntity

[IntentScarab]

Hello,

The title is a bit confusing, I know, but I'll explain more here.

I've been following MinecraftByExample's tutorial on a Furnace type block, since that is how my block kind of works. It has an object that holds the information about the block such as time, and what I have been using it for, experience points. Now I have this block that holds exp and has two inputs, an output, and four buttons. The buttons are working and doing what I want; when I click a button, the Container deals with the logic then sends the updated data to the TileEntity for it to be changed. I originally had everything the button does on the Container, but it wasn't saving the data when I closed the gui so I hope this is the way things are supposed to be.

Now that was all working, I got my recipe serializer working for the block, but before I worked on the recipe i/o, I wanted to work on the other input which is for my exp book, and it takes the exp from the book and transfers it to the actual block. I have worked through the logic for this specific area and it seems good, however it doesn't actually save the updated exp amount to the block.

I have stepped through with a debugger and I can see the exp being removed, and the block exp is increasing, but when I continue the program then the exp bar I have for the block hasn't increased and there isn't anything in the block afterall. Buttons work however.

 

TLDR: Input slot for custom item gets it's exp amount removed and passed over to the exp block, exp block doesn't save the amount. Buttons work however, even though both the buttons and BookInput slot basically go through the same hoops.

Code:

ExperienceBlockTile:

public class ExperienceBlockTile extends BaseTile implements INamedContainerProvider, ITickableTileEntity {

    public static final int INPUT_SLOTS = 1;
    public static final int INPUT_BOOK_SLOTS = 1;
    public static final int OUTPUT_SLOTS = 1;
    public static final int EXP_BAR_SLOT = 1;
    public static final int TOTAL_SLOTS = INPUT_SLOTS + OUTPUT_SLOTS;

    private ExperienceBlockContents inputContents;
    private ExperienceBlockContents inputBookContents;
    private ExperienceBlockContents outputContents;
    private ExperienceBlockContents expBarContents;

    private ItemStack currentlyInfusingItemLastTick = ItemStack.EMPTY;
    private ItemStack currentlyExtractionItemLastTick = ItemStack.EMPTY;

    public ExperienceBlock.Tier tier;
    public ExperienceBlockTile tile;

    private final ExperienceBlockStateData experienceBlockStateData;


    // Constructor that creates the experienceBlockTile and the input/output contents
    public ExperienceBlockTile(ExperienceBlock.Tier tier) {
        super(getTier(tier));

        inputContents = ExperienceBlockContents.createForTileEntity(INPUT_SLOTS,
                this::canPlayerAccessInventory,
                this::markDirty);

        inputBookContents = ExperienceBlockContents.createForTileEntity(INPUT_BOOK_SLOTS,
                this::canPlayerAccessInventory,
                this::markDirty);

        outputContents = ExperienceBlockContents.createForTileEntity(OUTPUT_SLOTS,
                this::canPlayerAccessInventory,
                this::markDirty);

        expBarContents = ExperienceBlockContents.createForTileEntity(EXP_BAR_SLOT,
                this::canPlayerAccessInventory,
                this::markDirty);

        this.tier = tier;
        this.tile = (ExperienceBlockTile) getTileEntity();

        this.experienceBlockStateData = new ExperienceBlockStateData();

    }

    @Override
    public ITextComponent getDisplayName() {
        return new TranslationTextComponent("experience_block_container");
    }

    @Nullable
    @Override
    public Container createMenu(int windowId, PlayerInventory playerIn, PlayerEntity playerEn) {
        return ExperienceBlockContainer.createContainerServerSide(windowId, playerIn, tile,
                inputContents, inputBookContents, outputContents, expBarContents, experienceBlockStateData);
    }

    // Basically just checks to see if the player is within range, true if they are

    public boolean canPlayerAccessInventory(PlayerEntity playerIn){
        if(this.world.getTileEntity(this.pos) != this){
            return false;
        }

        final double X_CENTRE_OFFSET = 0.5;
        final double Y_CENTRE_OFFSET = 0.5;
        final double Z_CENTRE_OFFSET = 0.5;
        final double MAXIMUM_DIST_SQ = 8.0 * 8.0;

        return playerIn.getDistanceSq(pos.getX() + X_CENTRE_OFFSET,
                pos.getY() + Y_CENTRE_OFFSET,
                pos.getZ() + Z_CENTRE_OFFSET) < MAXIMUM_DIST_SQ;
    }
    @Override
    public void tick() {

        // do nothing on client
        if(world.isRemote) return;


        ItemStack currentItemExpInfuse = getCurrentInfuseItemInput();
        ItemStack currentExtractionItemInput = getCurrentExpExtractItemInput();


        if(!currentExtractionItemInput.isEmpty()){
            extractExpItem();
        }

        currentlyExtractionItemLastTick = currentExtractionItemInput.copy();

        markDirty();
    }

    public static boolean doesItemHaveExpTag(ItemStack item){
        return item.getOrCreateTag().contains("exp");
    }

    private ItemStack getCurrentInfuseItemInput(){
        return infuseFirstSuitableInputItem(false);
    }

    private void infuseFirstSuitableInputItem(){
        infuseFirstSuitableInputItem(true);
    }

    private ItemStack infuseFirstSuitableInputItem(boolean performInfuse){

        Integer inputSlot = null;
        Integer outputSlot = null;

        return ItemStack.EMPTY;
    }

    private ItemStack getCurrentExpExtractItemInput(){
        return extractExpItem(false);
    }

    private void extractExpItem(){
        extractExpItem(true);
    }

    private ItemStack extractExpItem(boolean performExtract){

        ItemStack extractItem = inputBookContents.getStackInSlot(0);

        if(!performExtract){
            return extractItem;
        }

        int extractRate = getExtractRate();
        performExtraction(extractItem, extractRate);

        currentlyExtractionItemLastTick = extractItem;

        markDirty();
        return extractItem;

    }

    private void performExtraction(ItemStack extractItem, int extractRate){

        // Store the amount of exp currently in the book, and also the amount of exp that will be stored
        int expAmount = extractItem.getOrCreateTag().getInt("exp");
        int expBlockAmount = getExpBlockAmount();
        int expBlockMaxAmount = getMaxExpAmount();

        int extractedExp;

        // Base case for the lower, and upper end
        if(expAmount == 0 || expBlockAmount == expBlockMaxAmount){
            return;
        }

        // If the extract rate is higher than the amount of exp stored, then it'll go into the minus territory
        // If expAmount is less than the extractRate then the amount will be saved, otherwise just use the extractRate
        extractedExp = (expAmount < extractRate) ? expAmount : extractRate;


        // If the amount of exp being extracted goes over the cap in the exp block then bring it down
        if(expBlockAmount + extractedExp > expBlockMaxAmount){
            extractedExp = expBlockMaxAmount - expBlockAmount;
        }

        expAmount -= extractedExp;

        extractItem.getTag().putInt("exp", expAmount);
        addExpAmount(extractedExp);
    }

    public boolean willItemStackFit(ExperienceBlockContents experienceBlockContents, int slotIndex, ItemStack itemStackOrigin){
        ItemStack itemStackDest = experienceBlockContents.getStackInSlot(slotIndex);

        if(itemStackDest.isEmpty() || itemStackOrigin.isEmpty()){
            return true;
        }

        if(!itemStackOrigin.isItemEqual(itemStackDest)){
            return false;
        }

        return false;
    }

    private final String INPUT_SLOT_NBT = "inputSlot";

    private final String INPUT_BOOK_SLOT_NBT = "inputBookSlot";
    private final String OUTPUT_SLOT_NBT = "outputSlot";
    private final String EXP_BAR_NBT = "expBar";
    @Override
    public CompoundNBT write(CompoundNBT compound) {
        super.write(compound);

        experienceBlockStateData.putIntoNBT(compound);

        compound.put(INPUT_SLOT_NBT, inputContents.serializeNBT());
        compound.put(INPUT_BOOK_SLOT_NBT, inputBookContents.serializeNBT());
        compound.put(OUTPUT_SLOT_NBT, outputContents.serializeNBT());
        compound.put(EXP_BAR_NBT, expBarContents.serializeNBT());

        return compound;
    }

    @Override
    public void read(BlockState state, CompoundNBT nbt) {
        super.read(state, nbt);

        experienceBlockStateData.readFromNBT(nbt);

        CompoundNBT invNBT = nbt.getCompound(INPUT_SLOT_NBT);
        inputContents.deserializeNBT(invNBT);

        invNBT = nbt.getCompound(INPUT_BOOK_SLOT_NBT);
        inputBookContents.deserializeNBT(invNBT);

        invNBT = nbt.getCompound(OUTPUT_SLOT_NBT);
        outputContents.deserializeNBT(invNBT);

        invNBT = nbt.getCompound(EXP_BAR_NBT);
        expBarContents.deserializeNBT(invNBT);

        if(inputContents.getSizeInventory() != INPUT_SLOTS
                || inputBookContents.getSizeInventory() != INPUT_BOOK_SLOTS
                || outputContents.getSizeInventory() != OUTPUT_SLOTS
                || expBarContents.getSizeInventory() != EXP_BAR_SLOT){
            throw new IllegalArgumentException("Corrupted NBT: Number of inventory slots did not match expected");
        }

    }

    @Nullable
    @Override
    public SUpdateTileEntityPacket getUpdatePacket() {

        CompoundNBT updateTagTileEntityState = getUpdateTag();
        final int METADATA = 42;
        return new SUpdateTileEntityPacket(this.pos, METADATA, updateTagTileEntityState);

    }

    @Override
    public void onDataPacket(NetworkManager net, SUpdateTileEntityPacket pkt) {
        CompoundNBT updateTagTileEntityState = pkt.getNbtCompound();
        BlockState state = world.getBlockState(pos);
        handleUpdateTag(state, updateTagTileEntityState);
    }

    @Override
    public CompoundNBT getUpdateTag() {
        CompoundNBT nbt = new CompoundNBT();
        write(nbt);
        return nbt;
    }

    @Override
    public void handleUpdateTag(BlockState state, CompoundNBT tag) {
        read(state, tag);
    }

    public void dropContents(World world, BlockPos pos){
        InventoryHelper.dropInventoryItems(world, pos, inputContents);
        InventoryHelper.dropInventoryItems(world, pos, inputBookContents);
        InventoryHelper.dropInventoryItems(world, pos, outputContents);
    }

    public static boolean isItemValidForInputSlot(ItemStack item){
        return true;
    }

    public static boolean isItemValidForOutputSlot(ItemStack item){
        return true;
    }
                  
    public int getExpBlockAmount(){
        return experienceBlockStateData.expAmountInContainer;
    }

    // Methods for the Exp Manipulation for adding and removing exp from the player to the ExpBlock
    // Add Exp to the Block
    public void addExpAmount(int value){
        experienceBlockStateData.expAmountInContainer += value;
        markDirty();
    }

    // Take Exp from the Block
    public void takeExpAmount(int value){
        experienceBlockStateData.expAmountInContainer -= value;
        markDirty();
    }

    public static TileEntityType<ExperienceBlockTile> getTier(ExperienceBlock.Tier tier){
        switch (tier){
            case SMALL:
                return ModTiles.EXPERIENCE_BLOCK_TILES.get(ExperienceBlock.Tier.SMALL).get();
            case MEDIUM:
                return ModTiles.EXPERIENCE_BLOCK_TILES.get(ExperienceBlock.Tier.MEDIUM).get();
            case LARGE:
                return ModTiles.EXPERIENCE_BLOCK_TILES.get(ExperienceBlock.Tier.LARGE).get();
            case CREATIVE:
                return ModTiles.EXPERIENCE_BLOCK_TILES.get(ExperienceBlock.Tier.CREATIVE).get();
            default:
                throw new IllegalArgumentException("Unknown tier: " + tier);
        }
    }

    public int getMaxExpAmount(){
        return getMaxExpFromTier(tier);
    }

    public int getMaxExpFromTier(ExperienceBlock.Tier tier){
        switch(tier){
            case SMALL:
                return 1395;
            case MEDIUM:
                return 8670;
            case LARGE:
                return 30970;
            case CREATIVE:
                return Integer.MAX_VALUE;
            default:
                throw new IllegalArgumentException("Tier is not recognized: " + tier);
        }
    }

    private int getExtractRate(){
        switch (this.tier){
            case SMALL:
                return 10;
            case MEDIUM:
                return 15;
            case LARGE:
                return 20;
            case CREATIVE:
                return 100;
            default:
                throw new IllegalArgumentException("Unknown tier: " + tier);
        }
    }
}

ExperienceContainerBlock:

public class ExperienceBlockContainer extends BaseContainer {

    // Vanilla Inventory Basic slot counts -- 9 Slots for hotbar, 3x9 for inventory
    private static final int HOTBAR_SLOT_COUNT = 9;
    private static final int PLAYER_INVENTORY_ROW_COUNT = 3;
    private static final int PLAYER_INVENTORY_COLUMN_COUNT = 9;
    private static final int PLAYER_INVENTORY_SLOT_COUNT = PLAYER_INVENTORY_COLUMN_COUNT * PLAYER_INVENTORY_ROW_COUNT;
    private static final int VANILLA_SLOT_COUNT = HOTBAR_SLOT_COUNT + PLAYER_INVENTORY_SLOT_COUNT;
    // Vanilla Inventory Indexes
    private static final int VANILLA_FIRST_SLOT_INDEX = 0;
    private static final int HOTBAR_FIRST_SLOT_INDEX = VANILLA_FIRST_SLOT_INDEX;
    private static final int PLAYER_INVENTORY_FIRST_SLOT_INDEX = HOTBAR_FIRST_SLOT_INDEX + HOTBAR_SLOT_COUNT;

    // Experience Block Inventory slot counts
    public static final int INPUT_SLOTS = ExperienceBlockTile.INPUT_SLOTS;
    public static final int INPUT_BOOK_SLOTS = ExperienceBlockTile.INPUT_BOOK_SLOTS;
    public static final int OUTPUT_SLOTS = ExperienceBlockTile.OUTPUT_SLOTS;
    public static final int EXP_BAR_SLOT = ExperienceBlockTile.EXP_BAR_SLOT;
    // Experience Block Inventory Indexes
    private static final int INPUT_SLOT_INDEX = PLAYER_INVENTORY_FIRST_SLOT_INDEX + PLAYER_INVENTORY_SLOT_COUNT;
    private static final int INPUT_BOOK_SLOT_INDEX = INPUT_SLOT_INDEX + INPUT_BOOK_SLOTS;
    private static final int OUTPUT_SLOT_INDEX = INPUT_BOOK_SLOT_INDEX + OUTPUT_SLOTS;
    private static final int EXP_BAR_SLOT_INDEX = OUTPUT_SLOT_INDEX + EXP_BAR_SLOT;

    // Gui Pos of the player inventory grid
    public static final int PLAYER_INVENTORY_XPOS = 8;
    public static final int PLAYER_INVENTORY_YPOS = 84;

    private World world;

    private ExperienceBlockContents inputContents;
    private ExperienceBlockContents inputBookContents;
    private ExperienceBlockContents outputContents;
    private ExperienceBlockContents expBarContents;

    private ExperienceBlockStateData experienceBlockStateData;

    private ExperienceBlockTile experienceBlockTile;

    public ExperienceBlock.Tier tier;

    public ExperienceBlockContainer(int windowId, PlayerInventory playerIn){
        super(ModContainers.EXPERIENCE_BLOCK_CONTAINER.get(), windowId);
    }

    public static ExperienceBlockContainer createContainerServerSide(int windowId, PlayerInventory playerInventory, ExperienceBlockTile tile,
                                                                     ExperienceBlockContents inputZoneContents,
                                                                     ExperienceBlockContents inputBookZoneContents,
                                                                     ExperienceBlockContents outputZoneContents,
                                                                     ExperienceBlockContents expBarZoneContents,
                                                                     ExperienceBlockStateData experienceBlockStateData) {

        return new ExperienceBlockContainer(windowId, playerInventory, tile, inputZoneContents, inputBookZoneContents, outputZoneContents, expBarZoneContents, experienceBlockStateData);
    }

    public static ExperienceBlockContainer createContainerClientSide(int windowId, PlayerInventory playerInventory, ExperienceBlockTile tile) {

        ExperienceBlockContents inputZoneContents = ExperienceBlockContents.createForClientSideContainer(INPUT_SLOTS);
        ExperienceBlockContents inputBookZoneContents = ExperienceBlockContents.createForClientSideContainer(INPUT_BOOK_SLOTS);
        ExperienceBlockContents outputZoneContents = ExperienceBlockContents.createForClientSideContainer(OUTPUT_SLOTS);
        ExperienceBlockContents expBarZoneContents = ExperienceBlockContents.createForClientSideContainer(EXP_BAR_SLOT);
        ExperienceBlockStateData experienceBlockStateData = new ExperienceBlockStateData();


        return new ExperienceBlockContainer(windowId, playerInventory, tile, inputZoneContents, inputBookZoneContents, outputZoneContents, expBarZoneContents, experienceBlockStateData);
    }


    public ExperienceBlockContainer(int windowId, PlayerInventory playerIn, @Nullable ExperienceBlockTile tile, ExperienceBlockContents inputZoneContents,
                                    ExperienceBlockContents inputBookZoneContents, ExperienceBlockContents outputZoneContents,
                                    ExperienceBlockContents expBarZoneContents, ExperienceBlockStateData experienceBlockStateData) {

        super(ModContainers.EXPERIENCE_BLOCK_CONTAINER.get(), windowId);

        if (ModContainers.EXPERIENCE_BLOCK_CONTAINER.get() == null) {
            throw new IllegalStateException("Must Initialise ContainerType ExperienceBlockContainer before constructing a ExperienceBlockContainer!");
        }

        this.inputContents = inputZoneContents;
        this.inputBookContents = inputBookZoneContents;
        this.outputContents = outputZoneContents;
        this.expBarContents = expBarZoneContents;

        this.experienceBlockStateData = experienceBlockStateData;

        this.tier = tile.tier;

        this.world = playerIn.player.world;
        this.experienceBlockTile = tile;

        trackIntArray(experienceBlockStateData);


        // The amount of pixels from the first pixel of one slot to the next slot
        final int SLOT_SPACING_X = 18;
        final int SLOT_SPACING_Y = 18;

        // Gui Pos of the player hotbar
        final int HOTBAR_XPOS = 8;
        final int HOTBAR_YPOS = 142;

        // Adding the player's hotbar to the gui - (x,y) loc of each item
        for (int x = 0; x < HOTBAR_SLOT_COUNT; x++) {
            addSlot(new Slot(playerIn, x, HOTBAR_XPOS + SLOT_SPACING_X * x, HOTBAR_YPOS));
        }

        // Adding the rest of the player's inventory
        for (int y = 0; y < PLAYER_INVENTORY_ROW_COUNT; y++) {
            for (int x = 0; x < PLAYER_INVENTORY_COLUMN_COUNT; x++) {
                int slotNumber = HOTBAR_SLOT_COUNT + y * PLAYER_INVENTORY_COLUMN_COUNT + x;

                // Gets the location of the slot using the positions and slot spacing
                int xpos = PLAYER_INVENTORY_XPOS + x * SLOT_SPACING_X;
                int ypos = PLAYER_INVENTORY_YPOS + y * SLOT_SPACING_Y;

                addSlot(new Slot(playerIn, slotNumber, xpos, ypos));

            }
        }


        // Input Slot
        final int INPUT_SLOT_XPOS = 44;
        final int INPUT_SLOT_YPOS = 15;

        // This looks stupid just for one slot but it gives the chance to upgrade in the future if I really want to
        for (int i = 0; i < INPUT_SLOTS; i++) {
            addSlot(new SlotInput(inputZoneContents, i, INPUT_SLOT_XPOS + SLOT_SPACING_X * i, INPUT_SLOT_YPOS));
        }

        // Input Slot
        final int INPUT_BOOK_SLOT_XPOS = 77;
        final int INPUT_BOOK_SLOT_YPOS = 32;

        // This looks stupid just for one slot but it gives the chance to upgrade in the future if I really want to
        for (int i = 0; i < INPUT_SLOTS; i++) {
            addSlot(new SlotInputBook(inputBookZoneContents, i, INPUT_BOOK_SLOT_XPOS + SLOT_SPACING_X * i, INPUT_BOOK_SLOT_YPOS));
        }


        // Output Slot
        final int OUTPUT_SLOT_XPOS = 44;
        final int OUTPUT_SLOT_YPOS = 50;

        for (int i = 0; i < OUTPUT_SLOTS; i++) {
            addSlot(new SlotOutput(outputZoneContents, i, OUTPUT_SLOT_XPOS + SLOT_SPACING_X * i, OUTPUT_SLOT_YPOS));
        }

        // Exp Slot
//        final int EXP_SLOT_SPACING_X = 21;
//        final int EXP_SLOT_SPACING_Y = 72;
//
//        final int EXP_SLOT_XPOS = 8;
//        final int EXP_SLOT_YPOS = 7;
    }

    public double fractionOfExpAmount(){
        int expAmount = experienceBlockTile.getExpBlockAmount();
        if(expAmount == 0) return 0;
        double fraction = (double) expAmount / experienceBlockTile.getMaxExpFromTier(tier);;
        return MathHelper.clamp(fraction, 0.0, 1.0);
    }

    @Override
    public boolean canInteractWith(PlayerEntity playerIn) {
        return inputContents.isUsableByPlayer(playerIn) && outputContents.isUsableByPlayer(playerIn);
    }

    @Override
    public ItemStack transferStackInSlot(PlayerEntity playerIn, int index) {
        Slot sourceSlot = inventorySlots.get(index);

        if(sourceSlot == null || !sourceSlot.getHasStack()) return ItemStack.EMPTY;

        ItemStack sourceItemStack = sourceSlot.getStack();
        ItemStack sourceStackBeforeMerge = sourceItemStack.copy();
        boolean successfulTransfer = false;

        SlotZone sourceZone = SlotZone.getZoneFromIndex(index);

        switch (sourceZone){
            case OUTPUT_ZONE:
            case INPUT_ZONE:
            case INPUT_BOOK_ZONE:
                successfulTransfer = mergeInto(SlotZone.PLAYER_MAIN_INVENTORY, sourceItemStack, false);
                if(!successfulTransfer){
                    successfulTransfer = mergeInto(SlotZone.PLAYER_HOTBAR, sourceItemStack, false);
                }
                break;
            case PLAYER_HOTBAR:
            case PLAYER_MAIN_INVENTORY:
                if(ExperienceBlockTile.doesItemHaveExpTag(sourceItemStack)){
                    successfulTransfer = mergeInto(SlotZone.INPUT_BOOK_ZONE, sourceItemStack, false);
                }
                if(!successfulTransfer){
                    if(sourceZone == SlotZone.PLAYER_HOTBAR){
                        successfulTransfer = mergeInto(SlotZone.PLAYER_MAIN_INVENTORY, sourceItemStack, false);
                    } else {
                        successfulTransfer = mergeInto(SlotZone.PLAYER_HOTBAR, sourceItemStack, false);
                    }
                }
                break;
            default:
                throw new IllegalArgumentException("Unexpected sourceZone: " + sourceZone);
        }

        if(!successfulTransfer) return ItemStack.EMPTY;

        if(sourceItemStack.isEmpty()){
            sourceSlot.putStack(ItemStack.EMPTY);
        } else {
            sourceSlot.onSlotChanged();
        }

        if(sourceItemStack.getCount() == sourceStackBeforeMerge.getCount()){
            return ItemStack.EMPTY;
        }

        sourceSlot.onTake(playerIn, sourceItemStack);
        return sourceStackBeforeMerge;
    }

    private boolean mergeInto(SlotZone dest, ItemStack sourceItemStack, boolean fillFromEnd){
        return mergeItemStack(sourceItemStack, dest.firstIndex, dest.lastIndexPlus1, fillFromEnd);
    }

    private enum SlotZone{
        INPUT_ZONE(INPUT_SLOT_INDEX, INPUT_SLOTS),
        INPUT_BOOK_ZONE(INPUT_BOOK_SLOT_INDEX, INPUT_BOOK_SLOTS),
        OUTPUT_ZONE(OUTPUT_SLOT_INDEX, OUTPUT_SLOTS),
        EXP_ZONE(EXP_BAR_SLOT_INDEX, EXP_BAR_SLOT),
        PLAYER_MAIN_INVENTORY(PLAYER_INVENTORY_FIRST_SLOT_INDEX, PLAYER_INVENTORY_SLOT_COUNT),
        PLAYER_HOTBAR(HOTBAR_FIRST_SLOT_INDEX, HOTBAR_SLOT_COUNT);

        public final int firstIndex;
        public final int slotCount;
        public final int lastIndexPlus1;


        SlotZone(int firstIndex, int numberOfSlots){
            this.firstIndex = firstIndex;
            this.slotCount = numberOfSlots;
            this.lastIndexPlus1 = firstIndex + numberOfSlots;
        }

        public static SlotZone getZoneFromIndex(int slotIndex){
            for(SlotZone slotZone : SlotZone.values()){
                if(slotIndex >= slotZone.firstIndex && slotIndex < slotZone.lastIndexPlus1) return slotZone;
            }
            throw new IndexOutOfBoundsException("Unexpected slotIndex");
        }
    }

    //region Buttons for ExperienceBlockScreen

    // Plus Buttons ADD experience to the blockM
    // ADDING a single level to the block at a time
    public void singlePlusOnButtonPress(PlayerEntity playerIn){

        int expLevel = playerIn.experienceLevel;
        int expTotal = playerIn.experienceTotal;

        int expBlockAmount = experienceBlockTile.getExpBlockAmount();
        int expMaxAmount = experienceBlockTile.getMaxExpFromTier(tier);

        // Check if we have reached our cap
        if(expBlockAmount == expMaxAmount){
            return;
        }

        // The amount of exp to take away from the player
        int expToTake;

        // Check if the player is level 0, if they are then check if they have 6 or less exp to take the dregs,
        // else just take the exp normally
        if(expLevel == 0){
            if(expTotal < 7){
                expToTake = expTotal;
            }
            else{
                return;
            }
        } else{
            expToTake = ExperienceHelper.takeExpToPrevLevel(expLevel);
        }

        // Check if the amount coming in can fit well under the cap, if not
        // then lower the amount and continue
        if(expToTake + expBlockAmount > expMaxAmount){
            expToTake = expMaxAmount - expBlockAmount;
        }

        playerIn.giveExperiencePoints(-expToTake);
        experienceBlockTile.addExpAmount(expToTake);
    }

    // ADDING all of the levels to the block
    public void doublePlusOnButtonPress(PlayerEntity playerIn){

        int expLevel = playerIn.experienceLevel;
        int expTotal = playerIn.experienceTotal;

        int expBlockAmount = experienceBlockTile.getExpBlockAmount();
        int maxExp = experienceBlockTile.getMaxExpFromTier(tier);

        // Check if we have reached our cap
        if(expBlockAmount == maxExp){
            return;
        }

        // Check if player is level 0 and has less than 7 exp
        int expToTake;
        if(expLevel == 0){
            if(expTotal < 7){
                expToTake = expTotal;
            } else{
                return;
            }
        } else{
            expToTake = expTotal;
        }

        // Clean up the dregs in the player exp bar
        if(expToTake + expBlockAmount > maxExp){
            expToTake = maxExp - expBlockAmount;
        }

        playerIn.giveExperiencePoints(-expToTake);
        experienceBlockTile.addExpAmount(expToTake);
    }

    // Minus Buttons TAKE AWAY experience from the block
    // TAKE AWAY a single level from the block
    public void singleMinusOnButtonPress(PlayerEntity playerIn){

        int expLevel = playerIn.experienceLevel;
        int expTotal = playerIn.experienceTotal;

        int expBlockAmount = experienceBlockTile.getExpBlockAmount();
        int maxExp = experienceBlockTile.getMaxExpFromTier(tier);

        if(expBlockAmount == 0){
            return;
        }

        int expToTake;
        int amountNeededToNextLevel = ExperienceHelper.recieveExpToNextLevel(expLevel);

        // Clean up the dregs stored in the block
        if(amountNeededToNextLevel > expBlockAmount){
            expToTake = expBlockAmount;
        } else {
            expToTake = amountNeededToNextLevel;
        }

        playerIn.giveExperiencePoints(expToTake);
        experienceBlockTile.takeExpAmount(expToTake);
    }

    // TAKING AWAY all of the levels in the block
    public void doubleMinusOnButtonPress(PlayerEntity playerIn){

        int expLevel = playerIn.experienceLevel;
        int expTotal = playerIn.experienceTotal;

        int expBlockAmount = experienceBlockTile.getExpBlockAmount();
        int maxExp = experienceBlockTile.getMaxExpFromTier(tier);

        if(expBlockAmount == 0){
            return;
        }

        int expToTake = expBlockAmount;

        // Clean up the dregs stored in the block
        if(expToTake > expBlockAmount) {
            expToTake = expBlockAmount;
        }

        playerIn.giveExperiencePoints(expToTake);
        experienceBlockTile.takeExpAmount(expToTake);
    }
    //endregion


    public class SlotInput extends Slot {

        public SlotInput(IInventory inventoryIn, int index, int xPosition, int yPosition) {
            super(inventoryIn, index, xPosition, yPosition);
        }

        @Override
        public boolean isItemValid(ItemStack stack) {
            return ExperienceBlockTile.isItemValidForInputSlot(stack);
        }
    }

    public class SlotInputBook extends Slot {

        public SlotInputBook(IInventory inventoryIn, int index, int xPosition, int yPosition) {
            super(inventoryIn, index, xPosition, yPosition);
        }

        @Override
        public boolean isItemValid(ItemStack stack) {
            return ExperienceBlockTile.isItemValidForInputSlot(stack);
        }
    }

    public class SlotOutput extends Slot {

        public SlotOutput(IInventory inventoryIn, int index, int xPosition, int yPosition) {
            super(inventoryIn, index, xPosition, yPosition);
        }

        @Override
        public boolean isItemValid(ItemStack stack) {
            return ExperienceBlockTile.isItemValidForOutputSlot(stack);
        }
    }

    public class SlotExp extends Slot {

        public SlotExp(IInventory inventoryIn, int index, int xPosition, int yPosition) {
            super(inventoryIn, index, xPosition, yPosition);
        }
    }
}

And my github repo, under the correct branch: https://github.com/RhysGrabany/Experienced/tree/ticking_entity_exp_book

 

Thank you in advance! Hopefully I didn't do/say anything too dumb.

Edited March 30, 2021 by IntentScarab
Issue solved

[Draco18s]

  On 3/30/2021 at 12:26 PM, IntentScarab said:

when I click a button, the Container deals with the logic then sends the updated data to the TileEntity for it to be changed. I originally had everything the button does on the Container, but it wasn't saving the data when I closed the gui so I hope this is the way things are supposed to be.

Expand  

Shocker, the server controls game state. Doing things on the client means the server sends an update and overwrites the client's changed values making it look like "it didn't save."

Of course it didn't save, you didn't tell the server fuckall.

[IntentScarab]

TIL, and that's on me for being thoughtless on that part. Though I think I fixed that. If I'm making changes on the server only then why doesn't it "save" the changes?

[Draco18s]

Gui Screens are never on the server. As emphasized by the fact that the Screen class is in the client namespace.

[IntentScarab]

Is the TileEntity on the Server or Client side? Cause that's what I'm using here. I am making changes to an object that holds the data I need, kinda like how MBE does it. But I'm doing this through the tick method of the Tile. I look at the debugger and it says that the object has the amount of exp from the book, book has none, then when I try to get the exp out of the block using the buttons then it tells me I haven't got any exp in the block. Am I missing something here?

[IntentScarab]

  On 3/30/2021 at 4:51 PM, diesieben07 said:

A tile entity will exist on both server and client.

Expand  

Ahh okay, so it's server side usually but when the gui is opened it's client side, I'm guessing? I'm sorry, but I still don't understand how changing the data on the TE by the TE doesn't result in any change with the data. I'm reading through the code from MBE and there isn't something super obvious that I'm missing...

The only big change is that I pass my tile to the container, and they don't markDirty after modifying their furnaceStateData; they only do it on items being moved from one slot to the other from what I can see.

This is the MBE topic I'm using as reference btw.

 

[IntentScarab]

That worked!! One simple line and it worked. The update to the block state is in MBE, but I didn't think it pertained to me cause it was dealing with the faces of the block with fuel burning. Omg thank you so much.

Here, since I have you could I have some help on the same sort of problem? The item I have uses the durability bar to show how full it is, when it is getting the exp taken out of it the bar doesn't update. How would I update the durability bar of the item to go down as the amount decreases? Right now I have to right click on it and it tells me it is empty.

[IntentScarab]

For future reference, this is the code I added to make it work:

BlockState state = world.getBlockState(this.pos);
world.notifyBlockUpdate(this.pos, state, state, 2);

I added this to the end of my tick() method and it works.