Hey there,

 

So I have a prototype cable here, to transfer energy across a line, which detecting TEs along the way,

if one is found it sends energy to them.

 

However, it does not work, as in, the energy IS not transfer if one is found.

 

Here is the class:

public class TileEntityPipeEnergy extends TileEntityBase implements ITickable, ICustomEnergyReceiver, ISharingEnergyProvider {

    public EnergyStorage energyStorage = new EnergyStorage(6000, 6000);

    public TileEntityPipeEnergy() { super("energypipe"); }

    @Override
    public void updateEntity() {
        super.updateEntity();
        List<EnumFacing> possibleSides = getPossibleSides();
        if (!possibleSides.isEmpty()) {
            int forEach = energyStorage.getEnergyStored() / possibleSides.size();
            for (EnumFacing side : possibleSides) {
                BlockPos neighbor = pos.offset(side);
                TileEntity tile = worldObj.getTileEntity(neighbor);
                if (tile != null) {
                    if (tile instanceof ICustomEnergyReceiver) {
                        transferEnergyToTile((ICustomEnergyReceiver) tile, side, forEach);
                    } else if (tile instanceof ICustomEnergyReceiver) {
                        transferEnergyToTile((ICustomEnergyReceiver) tile, side, forEach);
                    }
                }
            }
        }
    }

    private void transferEnergyToTile(ICustomEnergyReceiver receiver, EnumFacing side, int energyAmount) {
        if (receiver.canConnectEnergy(side.getOpposite())) {
            receiver.receiveEnergy(side.getOpposite(), extractEnergy(side, energyAmount, false), false);
        }
    }

    public List<EnumFacing> getPossibleSides() {
        List<EnumFacing> sides = new ArrayList<EnumFacing>();
        for (EnumFacing side : EnumFacing.VALUES) {
            BlockPos neighbor = pos.offset(side);
            TileEntity tile = worldObj.getTileEntity(neighbor);
            if (tile != null) {
                if (tile instanceof IEnergyReceiver) {
                    sides.add(side);
                }
            }
        }

        if (sides.size() != 0) {
            int forEach = energyStorage.getEnergyStored() / sides.size();

            for (EnumFacing side : EnumFacing.VALUES) {
                if (sides.contains(side)) {
                    BlockPos neighbor = pos.offset(side);
                    TileEntity tile = worldObj.getTileEntity(neighbor);
                    if (tile != null && tile instanceof ICustomEnergyReceiver) {
                        ICustomEnergyReceiver receiver = (ICustomEnergyReceiver) tile;
                        if (receiver.getEnergyStored(side.getOpposite()) + forEach > receiver.getMaxEnergyStored(side.getOpposite())) {
                            sides.remove(side);
                        }
                        if (!receiver.canConnectEnergy(side.getOpposite())) {
                            sides.remove(side);
                        }
                    }
                }
            }
        }
        return sides;
    }

    public int getEnergyToSplitShare() {
        return this.getEnergyStored();
    }

    public boolean doesShareEnergy() {
        return true;
    }

    public EnumFacing[] getEnergyShareSides() {
        return EnumFacing.values();
    }

    @Override
    public void writeSyncableNBT(NBTTagCompound compound, NBTType type){
        super.writeSyncableNBT(compound, type);
        this.energyStorage.writeToNBT(compound);
    }

    @Override
    public void readSyncableNBT(NBTTagCompound compound, NBTType type){
        super.readSyncableNBT(compound, type);
        this.energyStorage.readFromNBT(compound);
    }

    @Override
    public int getEnergyStored(EnumFacing from) {
        return energyStorage.getEnergyStored();
    }

    @Override
    public int getMaxEnergyStored(EnumFacing from) {
        return energyStorage.getMaxEnergyStored();
    }

    public int getEnergyStored() {
        return energyStorage.getEnergyStored();
    }

    public int getMaxEnergyStored() {
        return energyStorage.getMaxEnergyStored();
    }

    @Override
    public boolean canConnectEnergy(EnumFacing from) {
        return worldObj.isBlockIndirectlyGettingPowered(pos) >= 1;
    }

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

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

}

 

Thanks for your time.

Why are you not using Capabilities?

I'm not particularly good with them Where should I read up on them? And how would I apply them to this?

I'm not particularly good with them Where should I read up on them? And how would I apply them to this?

Forge provides a Energy Capability you just need to override getCapability and hasCapability in your TE. This is also what you should be doing for inventories using the IItemHandler capability.

Look at the forge docs

http://mcforge.readthedocs.io/en/latest/datastorage/capabilities/

Yeah I do it with inventories with some help from others, however wasn't really given a reference on how they work. Thanks!

... So something like this?

 

    @Override
    public boolean hasCapability(Capability<?> capability, EnumFacing facing) {
        if(capability == CapabilityEnergy.ENERGY) {
            return true;
        }
        return super.hasCapability(capability, facing);
    }

    @Override
    public <T> T getCapability(Capability<T> capability, EnumFacing facing) {
        if (capability == CapabilityEnergy.ENERGY) {
            return (T) energyStorage;
        }
        return super.getCapability(capability, facing);
    }

 

at the bottom of the class? I'm handling the energy with CoFH API.

Using the Debugger, i found that it is finding the TE, however not transferring energy for some reason.