Between function calls, every value except the inventory is reset to their default values. The problem is that I cannot see where or why. The code is a mess as I have been trying to find a work around for this, but no system of notifying the client side of changes seems to keep the values, even the GUI set is reset to null. This doesn't seem right as I have accomplished the same thing in other custom TileEntity classes, using even more data. The question is why is this happening? Is there a clean way to correct this without having to create more classes?

package com.kittenkoder.magitech.tile;

import java.util.LinkedList;
import java.util.UUID;

import javax.annotation.Nullable;

import net.minecraft.block.Block;
import net.minecraft.block.state.IBlockState;
import net.minecraft.item.Item;
import net.minecraft.item.ItemBlock;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.EnumFacing;
import net.minecraft.util.ITickable;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
import net.minecraftforge.common.capabilities.Capability;
import net.minecraftforge.fml.common.network.NetworkRegistry;
import net.minecraftforge.items.CapabilityItemHandler;
import net.minecraftforge.items.ItemStackHandler;

import com.kittenkoder.magitech.Magitech;
import com.kittenkoder.magitech.MagitechOreRegistry;
import com.kittenkoder.magitech.blocks.IMagitechBlockVariant;
import com.kittenkoder.magitech.blocks.MagitechBlockFan;
import com.kittenkoder.magitech.blocks.MagitechBlockMachineCrusher;
import com.kittenkoder.magitech.blocks.MagitechBlockMachineSmelter;
import com.kittenkoder.magitech.gui.MagitechGUIMachine;
import com.kittenkoder.magitech.network.MagitechIntegerRequestUpdate;
import com.kittenkoder.magitech.network.MagitechUpdateFluid;
import com.kittenkoder.magitech.network.MagitechUpdateIntegerPacketClient;
import com.kittenkoder.magitech.network.MagitechUpdateRequestFluids;
import com.kittenkoder.magitech.network.containers.UpdatePostData;
import com.kittenkoder.magitech.util.MagitechFluidLevel;

public class MagitechTileEntityMachineSmelter extends MagitechTileEntityBox 
	implements IMagitechTileMachine, IMagitechTileEntityWatts, IMagitechBlockVariant,
	IMagitechTileInventory, IMagitechTileEntityIntegerUpdate, ITickable, IMagitechTileEntityFluid {

	protected final LinkedList<UpdatePostData> UPDATE_LIST;
	protected int _processtime = 0, _cooldown = 10;
	protected final MagitechFluidLevel _fluid_result;
	protected boolean _haspower = false;
	protected int _speed = 1, _capacity = 16;
	protected MagitechGUIMachine _gui;

	public MagitechTileEntityMachineSmelter() {
		super(1);
		this._fluid_result = new MagitechFluidLevel(MagitechOreRegistry.Fluids.ALUMINUM, 0);
		this.UPDATE_LIST = new LinkedList<UpdatePostData>();
		this._gui = null;
	}

	public void setGUI(MagitechGUIMachine gui) { 
		this._gui = gui;
		if(gui != null) Magitech.net.sendToServer(new MagitechUpdateRequestFluids(this));
	}
	
	@Override
   	public boolean shouldRefresh(World world, BlockPos pos, IBlockState oldState, IBlockState newState) {
		return (oldState.getBlock() != newState.getBlock());
    }
	
	public void setHasPower(boolean h, boolean update) { 
		this._haspower = h;
		if(!this.getWorld().isRemote){
			if(!h) {
				this._processtime = 0;
				this.setIntegerToUpdate(0, Flag.PROGRESS, null, true);
			} 
			
			if(update) {
				IBlockState bl = this.getWorld().getBlockState(this.getPos());
				if(bl != null && bl.getBlock() instanceof MagitechBlockMachineSmelter) {
					bl = bl.withProperty(MagitechBlockMachineSmelter.POWERED, this._haspower);
					this.getWorld().setBlockState(this.getPos(), bl);
				}
				this.markDirty();
			}
		}
	}
	public int getProgress() { return this._processtime; }
	public boolean getHasPower() { return this._haspower; }
	
	@Override
	public void setIntegerToUpdate(int i, IMagitechTileEntityIntegerUpdate.Flag flag, UUID player, boolean s) {
		if(this.getWorld().isRemote) {
			if(!s) {
				this._processtime = i;
			}
		} else {
			if(s) {
				this.UPDATE_LIST.add(new UpdatePostData(this, this._processtime, Flag.PROGRESS, null));
				Magitech.net.sendToAllAround(new MagitechUpdateIntegerPacketClient(this), new NetworkRegistry.TargetPoint(this.getWorld().provider.getDimension(), this.getPos().getX(), this.getPos().getY(), this.getPos().getZ(), 8));
			}
		}
	}

	@Override
	public NBTTagCompound writeToNBT(NBTTagCompound compound) {
		compound = super.writeToNBT(compound);
		compound.setInteger("MagitechProgress", this._processtime);
		compound.setInteger("MagitechSpeed", this._speed);
		compound.setInteger("MagitechCapacity", this._capacity);
		compound.setBoolean("MagitechPowered", this._haspower);
		this.writeFluidsToNBT(compound);
		return compound;
	}
	
	@Override
	public void readFromNBT(NBTTagCompound compound) {
		super.readFromNBT(compound);
		this._processtime = compound.getInteger("MagitechProgress");
		this._speed = compound.getInteger("MagitechSpeed");
		this._capacity = compound.getInteger("MagitechCapacity");
		this._haspower = compound.getBoolean("MagitechPowered");
		this.readFluidsFromNBT(compound);
	}
	
	@Override
	public int getNextUpdateInteger() {
		UpdatePostData n = this.UPDATE_LIST.getFirst();
		return n.value;
	}

	@Override
	public IMagitechTileEntityIntegerUpdate.Flag getNextUpdateFlag() {
		UpdatePostData n = this.UPDATE_LIST.getFirst();
		return n.flag;
	}

	@Override
	public void popNext() {
		this.UPDATE_LIST.remove();
	}

	@Override
	public ItemStack getStackInSlot(int index) {
		return this.inventory.getStackInSlot(0);
	}

	@Override
	public ItemStack removeStackFromSlot(int index) {
		ItemStack stack = this.inventory.getStackInSlot(0);
		this.inventory.setStackInSlot(0, ItemStack.EMPTY);
		return stack;
	}
	
	@Override
	public boolean hasCapability(Capability<?> capability, @Nullable EnumFacing facing) {
		if(this.inventory == null) return super.hasCapability(capability, facing);
		return (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY && facing == EnumFacing.UP) || super.hasCapability(capability, facing);
	}
	
	@SuppressWarnings("unchecked")
	@Nullable
	@Override
	public <T> T getCapability(Capability<T> capability, @Nullable EnumFacing facing) {
		if(this.inventory == null) return super.getCapability(capability, facing);
		if(capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY) {
			if(facing == EnumFacing.UP) return (T)this.inventory;
		}
		return super.getCapability(capability, facing);
	}

	@Override
	public void setInventorySlotContents(int index, ItemStack stack) {
		this.inventory.setStackInSlot(0, stack);
	}

	public void writeFluidsToNBT(NBTTagCompound compound) {
		NBTTagCompound fl = new NBTTagCompound();
		fl.setInteger("FluidCount", 1);
		String na = "Fluid";
		fl.setInteger(na + "Index", this._fluid_result._fluid.index);
		fl.setInteger(na + "Level", this._fluid_result._level);
		compound.setTag("MagitechFluid", fl);
		System.out.println("Level Writ: " + this._fluid_result._level);
		System.out.println("Fluid Writ: " + this._fluid_result._fluid.index);
	}	

	public void readFluidsFromNBT(NBTTagCompound compound) {
		if(compound.hasKey("MagitechFluid")) {
			NBTTagCompound fl = compound.getCompoundTag("MagitechFluid");
			String na = "Fluid";
			this._fluid_result.set(MagitechOreRegistry.Fluids.find(fl.getInteger(na + "Index")), fl.getInteger(na + "Level"));
			System.out.println("Level Read: " + this._fluid_result._level);
			System.out.println("Fluid read: " + this._fluid_result._fluid.index);
		}
	}
	
	@Override
	public ItemStackHandler getInventory() {
		return this.inventory;
	}

	@Override
	public int getWattLevel() {
		return 0;
	}

	@Override
	public void setWattLevel(int p) {
	}
	
	@Override
	public void onLoad() {
		if(this.getWorld().isRemote) {
			Magitech.net.sendToServer(new MagitechIntegerRequestUpdate(this, Flag.PROGRESS));
			Magitech.net.sendToServer(new MagitechUpdateRequestFluids(this));
			return;
		}
	}

	@Override
	public boolean takesWatts(EnumFacing face, IBlockState state) {
		return face == state.getValue(MagitechBlockMachineCrusher.VARIANT).face;
	}

	@Override
	public boolean suppliesWatts(EnumFacing face, IBlockState state) {
		return false;
	}

	@Override
	public void notifyMachineStructure(BlockPos cpos, World nworld) {
		this._speed = 1;
		for(int y = -5; y < 6 && this._speed < 99; y++) {
			BlockPos tpos = cpos.add(0, y, 0);
			if(tpos.getY() < 256 && tpos.getY() > 0) {
				for(int x = -5; x < 6 && this._speed < 99; x++) {
					for(int z = -5; z < 6 && this._speed < 99; z++) {
						BlockPos npos = tpos.add(x, 0, z);
						IBlockState tile = nworld.getBlockState(npos);
						if(tile != null) {
							Block tblock = tile.getBlock();
							if(tblock instanceof MagitechBlockFan) 
								this._speed = Math.min(99, this._speed + ((MagitechBlockFan)tblock).getRank() + 1);
						}
					}
				}
			}
		}
		this.markDirty();
	}

	@Override
	public void update() {
		if(this.getWorld().isRemote || !this._haspower) return;
		
		this._cooldown--;
		if(this._cooldown > 0) return;
		this._cooldown = 5;
		
		ItemStack stack = this.inventory.getStackInSlot(0);
		if(stack.isEmpty()) { 
			int lastproc = this._processtime;
			this._processtime = 0;
			if(lastproc != 0) this.setIntegerToUpdate(0, Flag.PROGRESS, null, true);
			return;
		}
		
		MagitechFluidLevel presult = null;
		MagitechOreRegistry.Ore ore;
		int level = 1;
		
		if(!stack.isEmpty()) {
			Item item = stack.getItem();
			ore = MagitechOreRegistry.byAllWithDust(item);
			if(ore == null && item instanceof ItemBlock) {
				Block block = ((ItemBlock)item).getBlock();
				ore = MagitechOreRegistry.byOre(block);
				if(ore == null) {
					ore = MagitechOreRegistry.byBlock(block);
					if(ore != null) level = 9;
				}
			}
			if(ore != null) presult = new MagitechFluidLevel(MagitechOreRegistry.Fluids.getByOre(ore), level);
		}

		boolean isvalid = presult != null && (this._fluid_result._level == 0 || (this._fluid_result._fluid == presult._fluid && this._fluid_result._level + presult._level <= this._capacity));
		if(!isvalid) {
			int lastproc = this._processtime;
			this._processtime = 0;
			if(lastproc != 0) this.setIntegerToUpdate(0, Flag.PROGRESS, null, true);
			this.markDirty();
			return;
		} else {
			this._processtime += this._speed;
			if(this._processtime < 100) {
				this.setIntegerToUpdate(0, Flag.PROGRESS, null, true);
				return;
			}
			this._processtime = 0;
			this.setIntegerToUpdate(0, Flag.PROGRESS, null, true);
			
			this.inventory.extractItem(0, 1, false);
			if(this._fluid_result._fluid != presult._fluid) this._fluid_result.set(presult);
			else this._fluid_result._level += presult._level;
			
			this.markDirty();
			Magitech.net.sendToAllAround(new MagitechUpdateFluid(this), new NetworkRegistry.TargetPoint(this.getWorld().provider.getDimension(), this.getPos().getX(), this.getPos().getY(), this.getPos().getZ(), 8));
		}
	}

	@Override
	public UUID getNextPlayer() {
		return null;
	}

	@Override
	public String getUnlocalizedName(int meta) {
		return this.blockType.getLocalizedName();
	}

	@Override
	public MagitechGUIMachine.Type getGUIType() {
		return MagitechGUIMachine.Type.SMELTER;
	}

	@Override
	public int getDataForInteger(Flag flag) {
		if(flag == Flag.PROGRESS) return this._processtime;
		return 0;
	}

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

	@Override
	public LinkedList<MagitechFluidLevel> getFluidLevels() {
		if(this._fluid_result != null) {
			LinkedList<MagitechFluidLevel> list = new LinkedList<MagitechFluidLevel>();
			list.add(this._fluid_result);
			return list;
		}
		return null;
	}

	@Override
	public void setFluidLevels(LinkedList<MagitechFluidLevel> f) {
		if(f != null && f.size() > 0) this._fluid_result.set(f.pop());
		else this._fluid_result._level = 0;
		
		if(this._gui != null) this._gui.setFluid(this._fluid_result._fluid, this._fluid_result._level);
		System.out.println("Level Rec: " + this._fluid_result._level);
		System.out.println("Fluid Rec: " + this._fluid_result._fluid.index);
		System.out.println("To GUI: " + this._gui);
	}
	
	@Override
	public MagitechFluidLevel getFluid(int i){
		return this._fluid_result;
	}
}

 

Edited January 28, 20187 yr by KittenKoder

Okay, I made the same mistake I have made before but stupid me didn't think to double check that part of the code. Seeing as how this is the first time I was stupid enough to start a thread on this, here was the issue:

 

I was looking at the wrong instance for Minecraft to get the tile entity in the data packet code. While the client was receiving the packet, and acting on it, it was getting the TE from the server world instead. Copy-pasta has some problems even when it's your own code. In case someone else finds this to be similar to their problem. Just make sure you look for the entity from the correct instance. Now I get to clean up my class.