Im creating a Campfire clone (with altered and added functionality). when i put meat in the campfire the data is stored, but the meat only appears when i reload the game. 

 

The TileEntity Class, most of it is basic campfire functionality.

Quote

public class ProCampfireTileEntity extends TileEntity implements IClearable, ITickableTileEntity {
    private final NonNullList<ItemStack> inventory = NonNullList.withSize(4, ItemStack.EMPTY);
       private final int[] cookingTimes = new int[4];
       private final int[] cookingTotalTimes = new int[4];

       public ProCampfireTileEntity(final TileEntityType<?> tileEntityTypeIn) {
          super(tileEntityTypeIn);
       }
       public ProCampfireTileEntity() {
          this(ModTileEntityTypes.CAMPFIRE.get());
       }

       public void tick() {
          boolean flag = this.getBlockState().get(ProCampfireBlock.LIT);
          boolean flag1 = this.world.isRemote;
          if (flag1) {
             if (flag) {
                this.addParticles();
             }

          } else {
             if (flag) {
                this.cookAndDrop();
             } else {
                for(int i = 0; i < this.inventory.size(); ++i) {
                   if (this.cookingTimes > 0) {
                      this.cookingTimes = MathHelper.clamp(this.cookingTimes - 2, 0, this.cookingTotalTimes);
                   }
                }
             }

          }
       }

       private void cookAndDrop() {
          for(int i = 0; i < this.inventory.size(); ++i) {
             ItemStack itemstack = this.inventory.get(i);
             if (!itemstack.isEmpty()) {
                ++this.cookingTimes;
                if (this.cookingTimes >= this.cookingTotalTimes) {
                   IInventory iinventory = new Inventory(itemstack);
                   ItemStack itemstack1 = this.world.getRecipeManager().getRecipe(IRecipeType.CAMPFIRE_COOKING, iinventory, this.world).map((p_213979_1_) -> {
                      return p_213979_1_.getCraftingResult(iinventory);
                   }).orElse(itemstack);
                   BlockPos blockpos = this.getPos();
                   InventoryHelper.spawnItemStack(this.world, (double)blockpos.getX(), (double)blockpos.getY(), (double)blockpos.getZ(), itemstack1);
                   this.inventory.set(i, ItemStack.EMPTY);
                   this.inventoryChanged();
                }
             }
          }

       }

       private void addParticles() {
          World world = this.getWorld();
          if (world != null) {
             BlockPos blockpos = this.getPos();
             Random random = world.rand;
             if (random.nextFloat() < 0.11F) {
                for(int i = 0; i < random.nextInt(2) + 2; ++i) {
                   ProCampfireBlock.spawnSmokeParticles(world, blockpos, this.getBlockState().get(ProCampfireBlock.SIGNAL_FIRE), false);
                }
             }

             int l = this.getBlockState().get(ProCampfireBlock.FACING).getHorizontalIndex();

             for(int j = 0; j < this.inventory.size(); ++j) {
                if (!this.inventory.get(j).isEmpty() && random.nextFloat() < 0.2F) {
                   Direction direction = Direction.byHorizontalIndex(Math.floorMod(j + l, 4));
                   //float f = 0.3125F;
                   double d0 = (double)blockpos.getX() + 0.5D - (double)((float)direction.getXOffset() * 0.3125F) + (double)((float)direction.rotateY().getXOffset() * 0.3125F);
                   double d1 = (double)blockpos.getY() + 0.5D;
                   double d2 = (double)blockpos.getZ() + 0.5D - (double)((float)direction.getZOffset() * 0.3125F) + (double)((float)direction.rotateY().getZOffset() * 0.3125F);

                   for(int k = 0; k < 4; ++k) {
                      world.addParticle(ParticleTypes.SMOKE, d0, d1, d2, 0.0D, 5.0E-4D, 0.0D);
                   }
                }
             }

          }
       }

       public NonNullList<ItemStack> getInventory() {
          return this.inventory;
       }

 

       public void read(CompoundNBT compound) {
          super.read(compound);
          this.inventory.clear();
          ItemStackHelper.loadAllItems(compound, this.inventory);
          if (compound.contains("CookingTimes", 11)) {
             int[] aint = compound.getIntArray("CookingTimes");
             System.arraycopy(aint, 0, this.cookingTimes, 0, Math.min(this.cookingTotalTimes.length, aint.length));
          }

          if (compound.contains("CookingTotalTimes", 11)) {
             int[] aint1 = compound.getIntArray("CookingTotalTimes");
             System.arraycopy(aint1, 0, this.cookingTotalTimes, 0, Math.min(this.cookingTotalTimes.length, aint1.length));
          }

       }

       public CompoundNBT write(CompoundNBT compound) {
          this.writeItems(compound);
          compound.putIntArray("CookingTimes", this.cookingTimes);
          compound.putIntArray("CookingTotalTimes", this.cookingTotalTimes);
          return compound;
       }

       private CompoundNBT writeItems(CompoundNBT compound) {
          super.write(compound);
          ItemStackHelper.saveAllItems(compound, this.inventory, true);
          return compound;
       }

       @Nullable
       public SUpdateTileEntityPacket getUpdatePacket() {
          return new SUpdateTileEntityPacket(this.pos, 13, this.getUpdateTag());
       }

       public CompoundNBT getUpdateTag() {
          return this.writeItems(new CompoundNBT());
       }

       public Optional<CampfireCookingRecipe> findMatchingRecipe(ItemStack itemStackIn) {
          return this.inventory.stream().noneMatch(ItemStack::isEmpty) ? Optional.empty() : this.world.getRecipeManager().getRecipe(IRecipeType.CAMPFIRE_COOKING, new Inventory(itemStackIn), this.world);
       }

       public boolean addItem(ItemStack itemStackIn, int cookTime) {
          for(int i = 0; i < this.inventory.size(); ++i) {
             ItemStack itemstack = this.inventory.get(i);
             if (itemstack.isEmpty()) {
                this.cookingTotalTimes = cookTime;
                this.cookingTimes = 0;
                this.inventory.set(i, itemStackIn.split(1));
                
                this.inventoryChanged();
                
                return true;
             }
          }
          return false;
       }
       
       private void inventoryChanged() {
          this.markDirty();
          this.getWorld().notifyBlockUpdate(this.getPos(), this.getBlockState(), this.getBlockState(), 3);
       }

       public void clear() {
          this.inventory.clear();
       }

       public void dropAllItems() {
          if (!this.getWorld().isRemote) {
             InventoryHelper.dropItems(this.getWorld(), this.getPos(), this.getInventory());
          }

          this.inventoryChanged();
       }
}

 

 

 

TileEntityRenderer

Quote

public class ProCampfireTileEntityRenderer extends TileEntityRenderer<ProCampfireTileEntity> {

    public ProCampfireTileEntityRenderer(TileEntityRendererDispatcher rendererDispatcherIn) {
        super(rendererDispatcherIn);
    }
    public static boolean msg;
    @Override
    public void render(ProCampfireTileEntity tileEntityIn, float partialTicks, MatrixStack matrixStackIn,IRenderTypeBuffer bufferIn, int combinedLightIn, int combinedOverlayIn) {
          Direction direction = tileEntityIn.getBlockState().get(ProCampfireBlock.FACING);
          NonNullList<ItemStack> nonnulllist = tileEntityIn.getInventory();   //Is always empty, even if its not supposed to. Fixes when reload.
          
          
          for(int i = 0; i < nonnulllist.size(); ++i) {
             ItemStack itemstack = nonnulllist.get(i); 
             if (itemstack != ItemStack.EMPTY) {       
                matrixStackIn.push();
                matrixStackIn.translate(0.5D, 0.44921875D, 0.5D);
                Direction direction1 = Direction.byHorizontalIndex((i + direction.getHorizontalIndex()) % 4);
                float f = -direction1.getHorizontalAngle();
                matrixStackIn.rotate(Vector3f.YP.rotationDegrees(f));
                matrixStackIn.rotate(Vector3f.XP.rotationDegrees(90.0F));
                matrixStackIn.translate(-0.3125D, -0.3125D, 0.0D);
                matrixStackIn.scale(0.375F, 0.375F, 0.375F);
                Minecraft.getInstance().getItemRenderer().renderItem(itemstack, ItemCameraTransforms.TransformType.FIXED, combinedLightIn, combinedOverlayIn, matrixStackIn, bufferIn);
                matrixStackIn.pop();
             }
          }

    }

}

 

 

 

 

Ive run debugs and the results seem very weird. The TileEntity tileEntityInst passed to the renderer for no apparent reason always has an empty inventory(even if the tile entity doesnt) this fixes when the game is reloaded.  I suspect the issue has something to do client data, and the getUpdatePacket() method being set up wrongly. or something, but im in the dark on the specifics of the problem/how to fix it. I know very little about packets or data storage, so a straight forward answer would be appreciated.

Edited August 17, 20205 yr by greetthemoth

Figured it out. Needed to put this function into my TileEntity class.

 

  @Override
       public void onDataPacket(NetworkManager net, SUpdateTileEntityPacket pkt){
            CompoundNBT tag = pkt.getNbtCompound();
            read(tag);
        }

 

the read() command is only called for vinilla TileEntities, instead the onDataPacket() function is called.