Jump to content
Search In
  • More options...
Find results that contain...
Find results in...

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


Recommended Posts

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 by IntentScarab
Issue solved
Link to post
Share on other sites
1 hour ago, 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.

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.

Apparently I'm a complete and utter jerk and come to this forum just like to make fun of people, be confrontational, and make your personal life miserable.  If you think this is the case, JUST REPORT ME.  Otherwise you're just going to get reported when you reply to my posts and point it out, because odds are, I was trying to be nice.

 

Exception: If you do not understand Java, I WILL NOT HELP YOU and your thread will get locked.

 

DO NOT PM ME WITH PROBLEMS. No help will be given.

Link to post
Share on other sites

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

Apparently I'm a complete and utter jerk and come to this forum just like to make fun of people, be confrontational, and make your personal life miserable.  If you think this is the case, JUST REPORT ME.  Otherwise you're just going to get reported when you reply to my posts and point it out, because odds are, I was trying to be nice.

 

Exception: If you do not understand Java, I WILL NOT HELP YOU and your thread will get locked.

 

DO NOT PM ME WITH PROBLEMS. No help will be given.

Link to post
Share on other sites

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?

Link to post
Share on other sites
3 minutes ago, diesieben07 said:

A tile entity will exist on both server and client.

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.

 

Link to post
Share on other sites

Both server and client have a copy of the world and thus a copy of the tile entity. You can find information about syncing data to the client version in the docs here: https://mcforge.readthedocs.io/en/latest/tileentities/tileentity/#synchronizing-on-block-update. If you only need the data within a GUI you can use the Container to sync the data instead to avoid unnecessary network traffic.

The other way around (client to server) is more complicated - the client generally cannot be trusted (otherwise you enable cheating). Most of the time you need a custom packet that tells the server that for example a button in the GUI was pressed, etc. The server then verifies that this is "okay right now" (e.g. the player is actually looking at the GUI at the moment) and performs the appropriate action.

  • Thanks 1
Link to post
Share on other sites

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.

Link to post
Share on other sites

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.

Link to post
Share on other sites
  • IntentScarab changed the title to (SOLVED) [1.16.4] Saving Block data doesn't work with TileEntity, but does when Container uses the TileEntity

Join the conversation

You can post now and register later. If you have an account, sign in now to post with your account.

Guest
Reply to this topic...

×   Pasted as rich text.   Restore formatting

  Only 75 emoji are allowed.

×   Your link has been automatically embedded.   Display as a link instead

×   Your previous content has been restored.   Clear editor

×   You cannot paste images directly. Upload or insert images from URL.



  • Recently Browsing

    No registered users viewing this page.

  • Posts

    • now I don't know how to help you you may want to create a new topic asking for help with that   the only thing that comes to mind isthat if you're on intelliJ, check if those are actaully subdirectories and not a single directory with dots in the name (as that is a very common problem that happens when people are modding with intelliJ)
    • Yes! thank you, it works great now. One more thing though, I followed default minecraft code for the armor, but even though I have all my layers in assets/gemstones/textures/models/armor it still shows up on my character as the 'no-texture' texture.
    • Exception message: java.lang.IllegalArgumentException: Duplicate registration jade you're registering "jade" twice, I think that should be the only thing wrong oh also, your enum constants should be all uppercased (it won't cause any errors of course, but it's the standard)  
    • Sure, i played around with the code a bit and added a ".get()" to the end of the material, this removed all errors. Except its wrong because now I launch and the game crashes, yet eclipse gives me no errors. Heres my list: package djofox.gemstones.materials; import java.util.function.Supplier; import djofox.gemstones.init.ItemInit; import net.minecraft.item.IItemTier; import net.minecraft.item.crafting.Ingredient; import net.minecraft.util.LazyValue; public enum ToolMaterialList implements IItemTier { beryl(0, 131, 15.0f, 2.75f, 30, () -> { return Ingredient.of(ItemInit.beryl.get()); }), jade(2, 500, 7.0f, 2.25f, 23, () -> { return Ingredient.of(ItemInit.jade.get()); }), moissanite(2, 500, 7.0f, 2.25f, 23, () -> { return Ingredient.of(ItemInit.moissanite.get()); }), kunzite(0, 315, 12f, 0.5f, 20, () -> { return Ingredient.of(ItemInit.kunzite.get()); }), orpiment(2, 258, 10f, 0.5f, 20, () -> { return Ingredient.of(ItemInit.orpiment.get()); }), mercurySulfide(2, 1012, 5.5f, 2.0f, 14, () -> { return Ingredient.of(ItemInit.mercurySulfide.get()); }), blackDiamond(3, 2757, 8.0f, 3.0f, 2, () -> { return Ingredient.of(ItemInit.blackDiamond.get()); }), treatedCarbide(4, 2560, 10.0f, 5.0f, 2, () -> { return Ingredient.of(ItemInit.siliconCarbide.get()); }); private final int level; private final int uses; private final float speed; private final float damage; private final int enchantmentValue; private final LazyValue<Ingredient> repairIngredient; private ToolMaterialList(int p_i48458_3_, int p_i48458_4_, float p_i48458_5_, float p_i48458_6_, int p_i48458_7_, Supplier<Ingredient> p_i48458_8_) { this.level = p_i48458_3_; this.uses = p_i48458_4_; this.speed = p_i48458_5_; this.damage = p_i48458_6_; this.enchantmentValue = p_i48458_7_; this.repairIngredient = new LazyValue<>(p_i48458_8_); } public int getUses() { return this.uses; } public float getSpeed() { return this.speed; } public float getAttackDamageBonus() { return this.damage; } public int getLevel() { return this.level; } public int getEnchantmentValue() { return this.enchantmentValue; } public Ingredient getRepairIngredient() { return this.repairIngredient.get(); } } Heres my init class which causes the crash (from taking other stuff) And heres the error I get when I crash (I dont know if you need it but better safe than sorry)  
    • can you show your ToolMaterialList?
  • Topics

  • Who's Online (See full list)

×
×
  • Create New...

Important Information

By using this site, you agree to our Privacy Policy.