I'm doing power cables using the Redstone Flux API, but I'm having some problems with the cable energy extraction. Could you help me? Feel free to make critical and show the best way to do it.

 

TileEntityPipe.class

 

package rennancge.dinamyc.tileentities;

import cofh.api.energy.EnergyStorage;
import cofh.api.energy.IEnergyConnection;
import cofh.api.energy.IEnergyHandler;
import cofh.api.energy.IEnergyHandler;
import net.minecraft.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;

public class TileEntityPipe extends TileEntity implements IEnergyHandler {

public ForgeDirection[] connections = new ForgeDirection[6];

protected EnergyStorage storage;
public int output;

public TileEntityPipe(int output) {
	this.output = output;
	this.storage = new EnergyStorage(200);

	storage.setMaxReceive(output);
	storage.setMaxExtract(output);
	storage.setMaxTransfer(output);
}

public void updateEntity() {
	this.updateConnections();

	if (storage.getEnergyStored() > 0) {
		for (int i = 0; i < 6; i++){

			//ForgeDirection is a useful helper class for handling directions.
			int targetX = xCoord + ForgeDirection.getOrientation(i).offsetX;
			int targetY = yCoord + ForgeDirection.getOrientation(i).offsetY;
			int targetZ = zCoord + ForgeDirection.getOrientation(i).offsetZ;

			TileEntity tile = worldObj.getTileEntity(targetX, targetY, targetZ);
			if (tile instanceof IEnergyHandler) {
				System.out.println("instanceof IEnergyHandler");
				int maxExtract = storage.getMaxExtract(); //Gets the maximum amount of energy that can be extracted from this tile in one tick.
				int maxAvailable = storage.extractEnergy(maxExtract, true); //Simulates removing "maxExtract" to find out how much energy is actually available.
				int energyTransferred = ((IEnergyHandler) tile).receiveEnergy(ForgeDirection.getOrientation(i).getOpposite(), maxAvailable, false); //Sends "maxAvailable" to the target tile and records how much energy was accepted. 

				storage.extractEnergy(energyTransferred, false);//Extract the energy transferred from the internal storage.
			}
		}
	}

}

public void updateConnections() {
	if(this.worldObj.getTileEntity(xCoord, yCoord + 1, zCoord) instanceof IEnergyHandler) connections[0] = ForgeDirection.UP;
	else connections[0] = null;

	if(this.worldObj.getTileEntity(xCoord, yCoord - 1, zCoord) instanceof IEnergyHandler) connections[1] = ForgeDirection.DOWN;
	else connections[1] = null;

	if(this.worldObj.getTileEntity(xCoord, yCoord, zCoord - 1) instanceof IEnergyHandler) connections[2] = ForgeDirection.NORTH;
	else connections[2] = null;

	if(this.worldObj.getTileEntity(xCoord, yCoord, zCoord + 1) instanceof IEnergyHandler) connections[3] = ForgeDirection.SOUTH;
	else connections[3] = null;

	if(this.worldObj.getTileEntity(xCoord + 1, yCoord, zCoord) instanceof IEnergyHandler) connections[4] = ForgeDirection.EAST;
	else connections[4] = null;

	if(this.worldObj.getTileEntity(xCoord - 1, yCoord, zCoord) instanceof IEnergyHandler) connections[5] = ForgeDirection.WEST;
	else connections[5] = null;
}

public boolean onlyOneOpposite(ForgeDirection[] directions) {
	ForgeDirection mainDirection = null;
	boolean isOpposite = false;

	for(int i = 0; i < directions.length; i++) {

		if(mainDirection == null && directions[i] != null) mainDirection = directions[i];

		if(directions[i] != null && mainDirection != directions[i]) {
			if(!isOpposite(mainDirection, directions[i])) return false;
			else isOpposite = true;
		}
	}

	return isOpposite;
}

public boolean isOpposite(ForgeDirection firstDirection, ForgeDirection secondDirection) {

	if((firstDirection.equals(ForgeDirection.NORTH) && secondDirection.equals(ForgeDirection.SOUTH)) || 
			firstDirection.equals(ForgeDirection.SOUTH) && secondDirection.equals(ForgeDirection.NORTH)) return true;

	if((firstDirection.equals(ForgeDirection.EAST) && secondDirection.equals(ForgeDirection.WEST)) || 
			firstDirection.equals(ForgeDirection.WEST) && secondDirection.equals(ForgeDirection.EAST)) return true;

	if((firstDirection.equals(ForgeDirection.UP) && secondDirection.equals(ForgeDirection.DOWN)) || 
			firstDirection.equals(ForgeDirection.DOWN) && secondDirection.equals(ForgeDirection.UP)) return true;

	return false;
}

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

@Override
public int receiveEnergy(ForgeDirection from, int maxReceive,
		boolean simulate) {

	if(storage.getEnergyStored() < storage.getMaxEnergyStored()) {
		return storage.getMaxReceive();
	}
	return 0;
}

@Override
public int extractEnergy(ForgeDirection from, int maxExtract,
		boolean simulate) {

	return storage.extractEnergy(storage.getMaxExtract(), simulate);
}

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

@Override
public int getMaxEnergyStored(ForgeDirection from) {
	// TODO Auto-generated method stub
	return storage.getMaxEnergyStored();
}


}

 

"if (storage.getEnergyStored ()> 0)" returns false, do not know why.

*bump* help-me please

Your not actually storing the energy you receive

@Override
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {

if(storage.getEnergyStored() < storage.getMaxEnergyStored()) {
	return storage.getMaxReceive();
}
return 0;
}

your returning max receive so it is accepting energy but you are not actually adding it to the energy storage that is why storage.getEnergyStored ()> 0 is always false because its always 0.

 

 

Your not actually storing the energy you receive

@Override
public int receiveEnergy(ForgeDirection from, int maxReceive, boolean simulate) {

if(storage.getEnergyStored() < storage.getMaxEnergyStored()) {
	return storage.getMaxReceive();
}
return 0;
}

your returning max receive so it is accepting energy but you are not actually adding it to the energy storage that is why storage.getEnergyStored ()> 0 is always false because its always 0.

 

 

 

It is drawing power from the power cube constantly, but does not send energy to another cube.

 

I also tried this:

@Override
public int receiveEnergy(ForgeDirection from, int maxReceive,
		boolean simulate) {

	if(storage.getEnergyStored() < storage.getMaxEnergyStored()) {
		return 20;
	}
	return 0;
}

Ok so it seems you arnt clear on how receive energy works. maxReceive is the amount that a tile is trying to push into your tile you need to take that and try to add it to your storage (i say try because your storage may be full or almost full) then you return the amount of energy that was successfully added to your storage and the tile sending will subtract that number from its storage. If the simulate flag is true you return the amount that would have been added to your storage but you dont actually add it because it is simulated (a way for things to check how much energy your tile can accept)

 

Here is what your receive energy should look like most of what i just described is handles by the EnergyStorage class so its very simple

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

I havent had a good look at the rest of your code so there may be other problems but that is the first one i noticed.

Oh! Thank you so much! Is working