[SOLVED][1.7.10] Tile Entity NBT not saving

[Guest]

I have a TileEntity which implements IEnergyHandler and has an EnergyStorage. When the world is closed, the energy storage is saved to NBT but the other values (an integer array and a simple integer) are not saving although they are also saved in the writeToNBT method. If I put a log output in the writeToNBT method, it doesn't seem to get called. I will provide code as soon as I am at home.

[Draco18s]

I will provide code as soon as I am at home.

 

Yeah, do that.  Without it your post is useless and we can't help you.  You may as well have waited to post until you got home.

[Guest]

Here you go:

package XFactHD.thermalreactors.common.blocks.machine.miscellaneous;

import XFactHD.thermalreactors.common.blocks.TileEntityBaseTR;
import XFactHD.thermalreactors.common.util.LogHelper;
import XFactHD.thermalreactors.common.util.Utils;
import cofh.api.energy.*;
import cofh.api.tileentity.IEnergyInfo;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.NetworkManager;
import net.minecraft.network.Packet;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;

public class TileEntityRFStorage extends TileEntityBaseTR implements IEnergyHandler, IEnergyInfo
{
    public EnergyStorage energyStorage = new EnergyStorage(320000000, 128000, 128000);
    public int[] sides = new int[]{1, 2, 1, 1, 1, 1};
    public int facing = 0;
    int last = 0;
    int ticks = 0;
    double chargePart;
    int result;

    public TileEntityRFStorage(){}

    @Override
    public boolean receiveClientEvent(int id, int arg)
    {
        if(id==0)
        {
            this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
            return true;
        }
        return false;
    }

    @Override
    public void updateEntity()
    {
        if(!worldObj.isRemote)
        {
            ticks++;
            if (ticks >= 20)
            {
                ticks = 0;
                if (last != getChargeIn8s())
                {
                    last = getChargeIn8s();
                    //LogHelper.info(energyStorage.getEnergyStored() + " " + chargePart + " " + result);
                    worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
                }
            }
            this.transferEnergy();
        }
    }

    @Override
    public void validate()
    {
        super.validate();
        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
    }

    @Override
    public void invalidate()
    {
        super.invalidate();
    }

    //IEnergyHandler
    @Override
    public boolean canConnectEnergy(ForgeDirection fd)
    {
        return sides[utils.getIntFromFD(fd)] > 0;
    }

    public void setSide(int id, int setting)
    {
        ForgeDirection fd = ForgeDirection.UNKNOWN;
        switch (facing)
        {
            case 0: switch (id)
            {
                case 0: fd = ForgeDirection.DOWN;
                case 1: fd = ForgeDirection.UP;
                case 2: fd = ForgeDirection.NORTH;
                case 3: fd = ForgeDirection.SOUTH;
                case 4: fd = ForgeDirection.WEST;
                case 5: fd = ForgeDirection.EAST;
            }
            case 1: switch (id)
            {
                case 0: fd = ForgeDirection.DOWN;
                case 1: fd = ForgeDirection.UP;
                case 2: fd = ForgeDirection.WEST;
                case 3: fd = ForgeDirection.EAST;
                case 4: fd = ForgeDirection.NORTH;
                case 5: fd = ForgeDirection.SOUTH;
            }
            case 2: switch (id)
            {
                case 0: fd = ForgeDirection.DOWN;
                case 1: fd = ForgeDirection.UP;
                case 2: fd = ForgeDirection.SOUTH;
                case 3: fd = ForgeDirection.NORTH;
                case 4: fd = ForgeDirection.EAST;
                case 5: fd = ForgeDirection.WEST;
            }
            case 3: switch (id)
            {
                case 0: fd = ForgeDirection.DOWN;
                case 1: fd = ForgeDirection.UP;
                case 2: fd = ForgeDirection.EAST;
                case 3: fd = ForgeDirection.WEST;
                case 4: fd = ForgeDirection.SOUTH;
                case 5: fd = ForgeDirection.NORTH;
            }
            default: fd = ForgeDirection.UNKNOWN;
        }

        sides[utils.getIntFromFD(fd)] = setting;
        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
    }

    public int getSide(int id)
    {
        switch (facing)
        {
            case 0: switch (id)
            {
                case 0: /*Bottom*/ return sides[0]; //Down
                case 1: /*Top*/ return sides[1]; //Up
                case 2: /*Front*/ return sides[2]; //North
                case 3: /*Back*/ return sides[3]; //South
                case 4: /*Right*/ return sides[4]; //West
                case 5: /*Left*/ return sides[5]; //East
            }
            case 1: switch (id)
            {
                case 0: /*Top*/ return sides[0];
                case 1: /*Bottom*/ return sides[1];
                case 2: /*Front*/ return sides[4];
                case 3: /*Back*/ return sides[5];
                case 4: /*Right*/ return sides[2];
                case 5: /*Left*/ return sides[3];
            }
            case 2: switch (id)
            {
                case 0: /*Top*/ return sides[0];
                case 1: /*Bottom*/ return sides[1];
                case 2: /*Front*/ return sides[3];
                case 3: /*Back*/ return sides[2];
                case 4: /*Right*/ return sides[5];
                case 5: /*Left*/ return sides[4];
            }
            case 3: switch (id)
            {
                case 0: /*Top*/ return sides[0];
                case 1: /*Bottom*/ return sides[1];
                case 2: /*Front*/ return sides[5];
                case 3: /*Back*/ return sides[4];
                case 4: /*Right*/ return sides[3];
                case 5: /*Left*/ return sides[2];
            }
            default: return 0;
        }
    }

    public int getChargeIn8s()
    {
        double chargePart = ((double)(energyStorage.getEnergyStored()/energyStorage.getMaxEnergyStored()));
        int result = ((int)chargePart*;
        return result;
    }

    @Override
    public int receiveEnergy(ForgeDirection fd, int amount, boolean simulate)
    {
        if (sides[utils.getIntFromFD(fd)] == 1 && !worldObj.isRemote)
        {
            return energyStorage.receiveEnergy(amount, simulate);
        }
        return 0;
    }

    @Override
    public int extractEnergy(ForgeDirection fd, int amount, boolean simulate)
    {
        if (sides[utils.getIntFromFD(fd)] == 2 && !worldObj.isRemote)
        {
            worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
            return energyStorage.extractEnergy(amount, simulate);
        }
        return 0;
    }

    @Override
    public int getEnergyStored(ForgeDirection forgeDirection)
    {
        return energyStorage.getEnergyStored();
    }

    @Override
    public int getMaxEnergyStored(ForgeDirection forgeDirection)
    {
        return energyStorage.getMaxEnergyStored();
    }

    protected void transferEnergy()
    {
        for(int i=0; i<6; i++)
        {
            ForgeDirection fd = ForgeDirection.VALID_DIRECTIONS[i];
            TileEntity tileEntity = worldObj.getTileEntity(xCoord+fd.offsetX, yCoord+fd.offsetY, zCoord+fd.offsetZ);
            if(sides[utils.getIntFromFD(fd)] == 2 && tileEntity instanceof IEnergyReceiver && ((IEnergyReceiver)tileEntity).receiveEnergy(fd.getOpposite(), this.energyStorage.getMaxExtract(), true) > 0 && this.energyStorage.getEnergyStored() > 0)
            {
                int received =((IEnergyReceiver)tileEntity).receiveEnergy(fd.getOpposite(), this.energyStorage.getMaxExtract(), false);
                this.energyStorage.setEnergyStored(this.energyStorage.getEnergyStored()-received);
            }
        }
    }


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

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

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

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

    //NBT Stuff
    @Override
    public void readFromNBT(NBTTagCompound nbt)
    {
        super.readFromNBT(nbt);
        sides = nbt.getIntArray("sides");
        energyStorage.readFromNBT(nbt);
        LogHelper.info("Reading from NBT");
    }

    @Override
    public void writeToNBT(NBTTagCompound nbt)
    {
        super.writeToNBT(nbt);
        nbt.setIntArray("sides", sides);
        energyStorage.writeToNBT(nbt);
        LogHelper.info("Writing to NBT");
    }

    @Override
    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt)
    {
        this.readFromNBT(pkt.func_148857_g());
        worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
    }

    @Override
    public Packet getDescriptionPacket()
    {
        NBTTagCompound nbttagcompound = new NBTTagCompound();
        this.writeToNBT(nbttagcompound);
        return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, 3, nbttagcompound);
    }

[Draco18s]

Well, your read/write methods are saving

sides

and the energy, but not anything else.  I also wouldn't trust "sides" to be sufficiently unique to avoid collision with something else.

 

As for your log method, try using

System.out.println()

instead, I am not sure what the LogHelper class is and how it works, but a line printed directly to the console should show up.

[Guest]

The LogHelper class is my own logging class, therefore I know that it works. I also got it fixed know. As you more or less mentioned, I should have put everything I want to save and read into the read and write methods.

 

That's the LogHelper class if you are interested:

package XFactHD.thermalreactors.common.util;

import cpw.mods.fml.common.FMLLog;
import org.apache.logging.log4j.Level;

public class LogHelper
{
    public static void log(Level logLevel, Object object)
    {
        FMLLog.log(Reference.MOD_NAME, logLevel, String.valueOf(object));
    }

    public static void all(Object object)
    {
        log(Level.ALL, object);
    }

    public static void debug(Object object)
    {
        log(Level.DEBUG, object);
    }

    public static void error(Object object)
    {
        log(Level.ERROR, object);
    }

    public static void fatal(Object object)
    {
        log(Level.FATAL, object);
    }

    public static void info(Object object)
    {
        log(Level.INFO, object);
    }

    public static void off(Object object)
    {
        log(Level.OFF, object);
    }

    public static void trace(Object object)
    {
        log(Level.TRACE, object);
    }

    public static void warn(Object object)
    {
        log(Level.WARN, object);
    }
}