[1.7.10] RF API Energy bar doesn't always update

[galaxyblast]

Okay, so I've been working on a mod using the Redstone Flux API (and a few other mods), and until recently I thought I had everything working. I've tried everything I can think of trying to fix this, but I have no clue.

There is one main problem, my Generators' GUI only updates the energy bar when one of 2 things are happening. If it's generating energy, or has an actual machine placed next to it.

Also, while the tile keeps it's energy upon quitting, when the world is reloaded the energy bar shows 0, even though the energy is still there.

 

If I put down my generator and start it, then place a machine directly next to it, the energy updates properly, but if I connect a cable/pipe to it, the energy will transfer, but the generator's GUI won't show it transferring.

 

Without pipes

 

Generate 800 RF

 

Put a machine next to it

 

It gets the power

 

And the generator loses it

 

 

With pipes

 

Generate 1000 RF

 

Use a pipe to connect it to a machine

 

The machine gets the power

 

The generator loses it, but doesn't show that it lost it

 

 

I've tried added System.out.print to the tile's update to see what the energy is doing, and if I use a pipe to extract the energy it will print 2 messages, 0 and whatever the energy used to be.

 

Here is my TileEntity code (warning, since I've been trying everything I can think of, it's a little messy)

package com.galaxyblast.advancedciv.tileentity;

import com.galaxyblast.advancedciv.ModItems;

import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyHandler;
import cofh.api.energy.IEnergyReceiver;
import cofh.api.energy.IEnergyStorage;
import cofh.core.block.TileCoFHBase;
import cpw.mods.fml.relauncher.Side;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;

public class MagGenTileEntity extends TileCoFHBase implements IEnergyHandler, IEnergyStorage, IInventory
{
private int capacity = 20000;
private int maxExtract = 100;
private int energy;
private ItemStack[] inventory = new ItemStack[4];
private String name;
private float cooldown;

private EnergyStorage storage = new EnergyStorage(this.capacity);;

public MagGenTileEntity()
{
	this.cooldown = 0.0F;
}

public EnergyStorage getStorage()
{
	return this.storage;
}

@Override
public boolean canConnectEnergy(ForgeDirection from)
{
	return true;
}

@Override
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate)
{
	return this.receiveEnergy(maxReceive, simulate);
}

@Override
public int extractEnergy(ForgeDirection from, int maxExtract, boolean simulate)
{
	return this.extractEnergy(maxExtract, simulate);
}

@Override
public int getEnergyStored(ForgeDirection from)
{
	return this.getEnergyStored();
}

@Override
public int getMaxEnergyStored(ForgeDirection from)
{
	return this.getMaxEnergyStored();
}

public final void setEnergyStored(int par1)
{
	this.setEnergyStored(par1);
}

@Override
public int getSizeInventory()
{
	return this.inventory.length;
}

@Override
public ItemStack getStackInSlot(int slot)
{
	if (slot < 0 || slot >= this.getSizeInventory())
		return null;

	return this.inventory[slot];
}

@Override
public ItemStack decrStackSize(int index, int count)
{
	if (this.getStackInSlot(index) != null)
	{
		ItemStack itemstack;

		if (this.getStackInSlot(index).stackSize <= count)
		{
			itemstack = this.getStackInSlot(index);
			this.setInventorySlotContents(index, null);
			this.markDirty();
			return itemstack;
		}
		else
		{
			itemstack = this.getStackInSlot(index).splitStack(count);

			if (this.getStackInSlot(index).stackSize <= 0)
			{
				this.setInventorySlotContents(index, null);
			}
			else
			{
				// Just to show that changes happened
				this.setInventorySlotContents(index, this.getStackInSlot(index));
			}

			this.markDirty();
			return itemstack;
		}
	}
	else
	{
		return null;
	}
}

@Override
public ItemStack getStackInSlotOnClosing(int slot)
{
	if (this.inventory[slot] != null)
	{
		ItemStack itemstack = this.inventory[slot];
		this.inventory[slot] = null;
		return itemstack;
	}
	else
		return null;
}

@Override
public void setInventorySlotContents(int slot, ItemStack itemstack)
{
	this.inventory[slot] = itemstack;

	if (itemstack != null && itemstack.stackSize > this.getInventoryStackLimit())
	{
		itemstack.stackSize = this.getInventoryStackLimit();
	}
}

@Override
public String getInventoryName()
{
	return "Electromagnetic Induction Generator";
}

@Override
public boolean hasCustomInventoryName()
{
	return false;
}

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

@Override
public void writeToNBT(NBTTagCompound nbt)
{
	super.writeToNBT(nbt);
	//this.storage.writeToNBT(nbt);
	nbt.setInteger("Energy", this.storage.getEnergyStored());
	this.storage.writeToNBT(nbt);

	NBTTagList list = new NBTTagList();
	for (int i = 0; i < this.getSizeInventory(); ++i)
	{
		if (this.getStackInSlot(i) != null)
		{
			NBTTagCompound stackTag = new NBTTagCompound();
			stackTag.setByte("Slot", (byte) i);
			this.getStackInSlot(i).writeToNBT(stackTag);
			list.appendTag(stackTag);
		}
	}

	nbt.setTag("Items", list);

	if (this.hasCustomInventoryName())
	{
		nbt.setString("CustomName", this.getInventoryName());
	}
}

@Override
public void readFromNBT(NBTTagCompound nbt)
{
	super.readFromNBT(nbt);
	//this.storage.readFromNBT(nbt);
	this.storage.readFromNBT(nbt);

	if(this.storage.getEnergyStored() > this.storage.getMaxEnergyStored())
		this.storage.setEnergyStored(this.storage.getMaxEnergyStored());

	NBTTagList list = nbt.getTagList("Items", 10);
	for (int i = 0; i < list.tagCount(); ++i)
	{
		NBTTagCompound stackTag = list.getCompoundTagAt(i);
		int slot = stackTag.getByte("Slot") & 255;
		this.setInventorySlotContents(slot, ItemStack.loadItemStackFromNBT(stackTag));
	}

	if (nbt.hasKey("CustomName", )
	{
		this.name = nbt.getString("CustomName");
	}
}

@Override
public boolean isUseableByPlayer(EntityPlayer player)
{
	return this.worldObj.getTileEntity(this.xCoord, this.yCoord, this.zCoord) != this ? false : player.getDistanceSq((double) this.xCoord - 0.5D, (double) this.yCoord - 0.5D, (double) this.zCoord - 0.5D) <= 64.0D;
}

@Override
public void openInventory()
{
	// TODO Auto-generated method stub
}

@Override
public void closeInventory()
{
	// TODO Auto-generated method stub
}

@Override
public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_)
{
	return false;
}

@Override
public int receiveEnergy(int maxReceive, boolean simulate)
{
	return this.storage.receiveEnergy(maxReceive, simulate);
}

@Override
public int extractEnergy(int maxExtract, boolean simulate)
{
	return this.storage.extractEnergy(maxExtract, simulate);
}

@Override
public int getEnergyStored()
{
	return this.storage.getEnergyStored();
}

@Override
public int getMaxEnergyStored()
{
	return this.storage.getMaxEnergyStored();
}

public int getEnergyScaled()
{
	return (int)(40.0F * (float)this.getEnergyStored() / (float)this.getMaxEnergyStored());
}

@Override
public void updateEntity()
{
	super.updateEntity();
	if(this.getEnergyStored() > 0)
		this.transmitEnergy();

	if(this.getStackInSlot(0) != null && this.getStackInSlot(0).getItem() == ModItems.magnet)
	{
		if(this.getStackInSlot(0).getItemDamage() == 0)
			this.receiveEnergy(5, false);
		else if(this.getStackInSlot(0).getItemDamage() == 1)
			this.receiveEnergy(100, false);
		else if(this.getStackInSlot(0).getItemDamage() == 2)
		{
			if(this.getStackInSlot(3) != null && this.getStackInSlot(3).getItem() == ModItems.coolingUpgrade && this.getStackInSlot(3).getItemDamage() == 2)
				this.receiveEnergy(5000, false);
		}
	}

	if(this.getStackInSlot(1) != null && this.getStackInSlot(1).getItem() == ModItems.outputUpgrade)
	{
		int type = this.getStackInSlot(1).getItemDamage();
		if(type == 0)
			this.maxExtract = 1000;
		else if(type == 1)
			this.maxExtract = 5000;
		else if(type == 2)
			this.maxExtract = 25000;
	}
	else if(this.getStackInSlot(1) == null)
		this.maxExtract = 100;

	this.storage.setMaxExtract(this.maxExtract);
	sendUpdatePacket(Side.CLIENT);

	System.out.print(this.getEnergyStored() + "\n");
}

private void transmitEnergy()
{
	for (ForgeDirection side : ForgeDirection.VALID_DIRECTIONS)
	{
		TileEntity tile = this.worldObj.getTileEntity(this.xCoord + side.offsetX, this.yCoord + side.offsetY, this.zCoord + side.offsetZ);
		if (!(tile instanceof MagGenTileEntity))
		{
			if ((tile instanceof IEnergyReceiver))
			{
				this.getStorage().extractEnergy(((IEnergyReceiver) tile).receiveEnergy(side.getOpposite(), getStorage().extractEnergy(this.maxExtract, true), false), false);
			}
		}
	}
}

public String getName()
{
	// TODO Auto-generated method stub
	return null;
}


public int getType()
{
	// TODO Auto-generated method stub
	return 0;
}
}

 

And here's my GUI code

package com.galaxyblast.advancedciv.gui;

import java.util.List;

import org.lwjgl.opengl.GL11;

import com.galaxyblast.advancedciv.AdvancedCivilizations;
import com.galaxyblast.advancedciv.blocks.containers.ContainerMagGen;
import com.galaxyblast.advancedciv.tileentity.MagGenTileEntity;

import net.minecraft.client.gui.inventory.GuiContainer;
import net.minecraft.client.resources.I18n;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.util.ResourceLocation;

public class GuiMagGen extends GuiContainer
{
private static final ResourceLocation ui = new ResourceLocation(AdvancedCivilizations.MODID, "textures/gui/magGen.png");
private static final ResourceLocation progress = new ResourceLocation(AdvancedCivilizations.MODID, "textures/gui/energyBar.png");
private MagGenTileEntity tile;

public GuiMagGen(InventoryPlayer playerInv, MagGenTileEntity te)
{
	super(new ContainerMagGen(playerInv, te));
	this.xSize = 176;
	this.ySize = 166;
	this.tile = te;
}

@Override
protected void drawGuiContainerForegroundLayer(int p_146979_1_, int p_146979_2_)
    {
        this.fontRendererObj.drawString("EIG", 80, 6, 4210752);
        this.fontRendererObj.drawString(I18n.format("container.inventory", new Object[0]), 8, this.ySize - 96 + 2, 4210752);
        this.fontRendererObj.drawString(this.tile.getEnergyStored() + " RF", 9, 14, 4210752);
        //System.out.print("X: " + String.valueOf(this.tile.xCoord) + "Y: " + String.valueOf(this.tile.yCoord) + "Z: " + String.valueOf(this.tile.zCoord) + "\n");
    }

@Override
protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY)
{
	GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
        this.mc.getTextureManager().bindTexture(ui);
        int k = (this.width - this.xSize) / 2;
        int l = (this.height - this.ySize) / 2;
        this.drawTexturedModalRect(k, l, 0, 0, this.xSize, this.ySize);
        
        this.mc.getTextureManager().bindTexture(progress);
        int energy = this.tile.getEnergyScaled();
        k = (this.width - 156) / 2;
        l = (this.height - 122 + ((41 - energy) * 2)) / 2;
        this.drawTexturedModalRect(k, l, 0, 0, 12, energy);
}
}

[ovikk]

Could you show us your container? All the magic power displaying happens there.

 

In your updateEntity() in your tileentity, most of that code should happen on the server.

[galaxyblast]

package com.galaxyblast.advancedciv.blocks.containers;

import com.galaxyblast.advancedciv.tileentity.MagGenTileEntity;
import com.galaxyblast.advancedciv.utils.SuperCraftingManager;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryCraftResult;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.inventory.Slot;
import net.minecraft.inventory.SlotCrafting;
import net.minecraft.item.ItemStack;
import net.minecraft.item.crafting.CraftingManager;
import net.minecraft.world.World;

public class ContainerMagGen extends Container
{
private MagGenTileEntity te;
    private World worldObj;

public ContainerMagGen(InventoryPlayer playerInv, MagGenTileEntity teIn)
{
	this.te = teIn;
	this.worldObj = playerInv.player.worldObj;

	//Magnet
	this.addSlotToContainer(new Slot(this.te, 0, 80, 35));

	//Upgrades
	for (int y = 0; y < 3; ++y)
	{
        for (int x = 0; x < 1; ++x)
        {
            this.addSlotToContainer(new Slot(this.te, x + y + 1, 153 + x * 18, 15 + y * 18));
        }
    }

	//Player inventory
	for (int y = 0; y < 3; ++y)
	{
        for (int x = 0; x < 9; ++x)
        {
            this.addSlotToContainer(new Slot(playerInv, x + y * 9 + 9, 8 + x * 18, 84 + y * 18));
        }
    }

	//Player Hotbar
	for (int x = 0; x < 9; ++x)
	{
        this.addSlotToContainer(new Slot(playerInv, x, 8 + x * 18, 142));
    }
}

@Override
public boolean canInteractWith(EntityPlayer player)
{
	return this.te.isUseableByPlayer(player);
}

@Override
public ItemStack transferStackInSlot(EntityPlayer playerIn, int fromSlot) 
{
    ItemStack previous = null;
    Slot slot = (Slot) this.inventorySlots.get(fromSlot);

    if (slot != null && slot.getHasStack())
    {
        ItemStack current = slot.getStack();
        previous = current.copy();

        if (fromSlot < 4)
        {
            // From TE Inventory to Player Inventory
            if (!this.mergeItemStack(current, 4, 40, true))
                return null;
        }
        else
        {
            // From Player Inventory to TE Inventory
            if (!this.mergeItemStack(current, 0, 4, false))
                return null;
        }

        if (current.stackSize == 0)
            slot.putStack((ItemStack) null);
        else
            slot.onSlotChanged();

        if (current.stackSize == previous.stackSize)
            return null;
        slot.onPickupFromSlot(playerIn, current);
    }
    return previous;
}
}

[Cerandior]

He is drawing the energy bar on the gui. I don't think the container have much to do with it. I looked through you read and write to NBT aswell as your updateEntity code. I think i have maybe found the problem but i am not sure of something. Is a pipe supossed to extract energy from a storage or your "generator" has to send energy to the pipe?

[galaxyblast]

My generator is set to send energy out to whatever is next to it and implements IEnergyReceiver. I'm not sure whether or not the pipe also tries to take energy from the generator on it's own. The pipes I'm using are from Thermal Dynamics and I can't seem to find the source for it to check.

Though even if I don't use pipes, when I reload the world the GUI doesn't show how much RF is stored, even though there is some there.

[ovikk]

I've had some problems with this in the past, so I now what made it work for me...

 

In your container class, you need to override some specific functions:

 

• void addCraftingToCrafters(ICrafting icrafting)
  
• void detectAndSendChanges()
  
• void updateProgressBar(int slot, int newValue)
  

 

If you look in minecrafts ContainerFurnace class, you'll se that the furnace overrites these functions.

All you have to do, is do the exactly the same with your Power variable. The slot variable in the updateProgressBar function have nothing to do with the item slots, at least in my experience.

[galaxyblast]

Oh my god, thank you so much!