+ Added the basework for Super Conductivity related machines & cabling.

> Lossless power transfer is always nice, eh?

% Refactored a few tooltips on machines.
% Refactored some classes around.

- Removed some obscure legacy code, which added a Cobblestone fueled boiler (Why?)

24 files changed, 4689 insertions, 306 deletions

diff --git a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java
index 2000a1df34..6f8935c51d 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechItemList.java
@@ -97,7 +97,9 @@ public enum GregtechItemList implements GregtechItemContainer {
 	
 	
 	Food_Baked_Raisin_Bread, 
-	Industrial_SinterFurnace;
+	Industrial_SinterFurnace, 
+	
+	SuperConductorInputNode;
 
 	public static final GregtechItemList[]
 			DYE_ONLY_ITEMS = {
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java
index ba6ad6ce41..824f7c99cb 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/enums/GregtechOrePrefixes.java
@@ -308,6 +308,7 @@ public enum GregtechOrePrefixes {
 		Neutronic(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "LuV Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 6), new TC_AspectStack(TC_Aspects.MACHINA, 6))),
 		Quantum(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 255, 255, 255, 0, "ZPM Tier", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeLightGray, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8), new TC_AspectStack(TC_Aspects.MACHINA, 8))),
 
+		Superconductor(-1, TextureSet.SET_NONE, 1.0F, 0, 0, 0, 190, 240, 190, 0, "Superconductor", 0, 0, -1, 0, false, false, 1, 1, 1, Dyes.dyeGreen, Arrays.asList(new TC_AspectStack(TC_Aspects.ELECTRUM, 8))),
 		
 		Staballoy(30, TextureSet.SET_ROUGH, 10.0F, 5120, 4, 1 | 2  | 16 | 32 | 64 | 128, 248, 255, 46, 0, "Staballoy", 0, 0, 1500, 2800, true, false, 1, 3, 1, Dyes.dyeGreen, 2, Arrays.asList(new MaterialStack(Materials.Titanium, 1), new MaterialStack(Materials.Uranium, 9)), Arrays.asList(new TC_AspectStack(TC_Aspects.METALLUM, 8), new TC_AspectStack(TC_Aspects.STRONTIO, 3))),
 		Bedrockium(31, TextureSet.SET_FINE, 8.0F, 8196, 3, 1 | 2 | 16 | 32 | 64 | 128, 39, 39, 39, 0, "Bedrockium", 0, 0, -1, 0, false, false, 1, 5, 1, Dyes.dyeLightGray, 2, Arrays.asList(new MaterialStack(Materials.Carbon, 63), new MaterialStack(Materials.Carbon, 56)),   Arrays.asList(new TC_AspectStack(TC_Aspects.VACUOS, 8), new TC_AspectStack(TC_Aspects.TUTAMEN, 3))),
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java b/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java
index 0cc4fc259b..0b7d80c940 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/gui/CONTAINER_SteamCondenser.java
@@ -5,7 +5,7 @@ import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
 
 import java.util.Iterator;
 
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaBoilerBase;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraft.inventory.ICrafting;
 import net.minecraft.inventory.Slot;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
index d069ff2c83..4ab969c483 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
@@ -12,7 +12,7 @@ import miscutil.core.util.Utils;
 import miscutil.core.util.math.MathUtils;
 import miscutil.core.xmod.gregtech.api.gui.CONTAINER_SteamCondenser;
 import miscutil.core.xmod.gregtech.api.gui.GUI_SteamCondenser;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaBoilerBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.generators.GregtechMetaBoilerBase;
 import net.minecraft.entity.player.InventoryPlayer;
 import net.minecraftforge.common.util.ForgeDirection;
 import net.minecraftforge.fluids.FluidStack;
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java
new file mode 100644
index 0000000000..7b6c670be4
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_SuperConductor.java
@@ -0,0 +1,239 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations;
+
+import static gregtech.api.enums.GT_Values.VN;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.TextureSet;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntityCable;
+import gregtech.api.interfaces.tileentity.IColoredTileEntity;
+import gregtech.api.interfaces.tileentity.IEnergyConnected;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.BaseMetaPipeEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import ic2.api.energy.tile.IEnergySink;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+
+import miscutil.core.lib.CORE;
+import miscutil.core.xmod.gregtech.api.enums.GregtechOrePrefixes.GT_Materials;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaPipeEntityBase_Cable;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.world.World;
+import net.minecraftforge.common.util.ForgeDirection;
+import cofh.api.energy.IEnergyReceiver;
+
+public class GregtechMetaPipeEntity_SuperConductor extends GregtechMetaPipeEntityBase_Cable implements IMetaTileEntityCable {
+	public long mTransferredAmperage = 0, mTransferredAmperageLast20 = 0, mTransferredVoltageLast20 = 0;
+
+	public final float mThickNess;
+	public final GT_Materials mMaterial;
+	public final long mCableLossPerMeter, mAmperage, mVoltage;
+	public final boolean mInsulated, mCanShock;
+	public long mRestRF;
+
+	public GregtechMetaPipeEntity_SuperConductor(int aID, String aName, String aNameRegional, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aID, aName, aNameRegional, 0, aMaterial, 0, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = 0;
+	}
+
+	public GregtechMetaPipeEntity_SuperConductor(String aName, float aThickNess, GT_Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aName, 0, aMaterial, 0, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = 0;
+	}
+
+	@Override
+	public byte getTileEntityBaseType() {
+		return (byte)(mInsulated?9:8);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaPipeEntity_SuperConductor(mName, mThickNess, mMaterial, mCableLossPerMeter, mAmperage, mVoltage, mInsulated, mCanShock);
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aConnections, byte aColorIndex, boolean aConnected, boolean aRedstone) {
+		if (!mInsulated) return new ITexture[]					{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa)};
+		if (aConnected) {
+			float tThickNess = getThickNess();
+			if (tThickNess < 0.37F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_TINY	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.49F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_SMALL	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.74F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_MEDIUM	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			if (tThickNess < 0.99F) return new ITexture[]		{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_LARGE	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+			return new ITexture[]								{new GT_RenderedTexture(mMaterial.mIconSet.mTextures[TextureSet.INDEX_wire], mMaterial.mRGBa), new GT_RenderedTexture(Textures.BlockIcons.INSULATION_HUGE	, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+		}
+		return new ITexture[]									{new GT_RenderedTexture(Textures.BlockIcons.INSULATION_FULL, Dyes.getModulation(aColorIndex, Dyes.CABLE_INSULATION.mRGBa))};
+	}
+
+	@Override
+	public void onEntityCollidedWithBlock(World aWorld, int aX, int aY, int aZ, Entity aEntity) {
+		if (mCanShock && (((BaseMetaPipeEntity)getBaseMetaTileEntity()).mConnections & -128) == 0 && aEntity instanceof EntityLivingBase) GT_Utility.applyElectricityDamage((EntityLivingBase)aEntity, mTransferredVoltageLast20, mTransferredAmperageLast20);
+	}
+
+	@Override
+	public AxisAlignedBB getCollisionBoundingBoxFromPool(World aWorld, int aX, int aY, int aZ) {
+		if (!mCanShock) return super.getCollisionBoundingBoxFromPool(aWorld, aX, aY, aZ);
+		return AxisAlignedBB.getBoundingBox(aX+0.125D, aY+0.125D, aZ+0.125D, aX+0.875D, aY+0.875D, aZ+0.875D);
+	}
+	
+	@Override public boolean isSimpleMachine()						{return true;}
+	@Override public boolean isFacingValid(byte aFacing)			{return false;}
+	@Override public boolean isValidSlot(int aIndex)				{return true;}
+   // @Override public final boolean renderInside(byte aSide)			{return false;}
+    @Override public int getProgresstime()							{return (int)mTransferredAmperage*64;}
+    @Override public int maxProgresstime()							{return (int)mAmperage*64;}
+
+	@Override
+	public long injectEnergyUnits(byte aSide, long aVoltage, long aAmperage) {
+		if (!getBaseMetaTileEntity().getCoverBehaviorAtSide(aSide).letsEnergyIn(aSide, getBaseMetaTileEntity().getCoverIDAtSide(aSide), getBaseMetaTileEntity().getCoverDataAtSide(aSide), getBaseMetaTileEntity())) return 0;
+		return transferElectricity(aSide, aVoltage, aAmperage, new ArrayList<TileEntity>(Arrays.asList((TileEntity)getBaseMetaTileEntity())));
+	}
+
+	@Override
+	public long transferElectricity(byte aSide, long aVoltage, long aAmperage, ArrayList<TileEntity> aAlreadyPassedTileEntityList) {
+		long rUsedAmperes = 0;
+		aVoltage -= mCableLossPerMeter;
+		if (aVoltage > 0) for (byte i = 0; i < 6 && aAmperage > rUsedAmperes; i++) if (i != aSide && (mConnections & (1<<i)) != 0 && getBaseMetaTileEntity().getCoverBehaviorAtSide(i).letsEnergyOut(i, getBaseMetaTileEntity().getCoverIDAtSide(i), getBaseMetaTileEntity().getCoverDataAtSide(i), getBaseMetaTileEntity())) {
+			TileEntity tTileEntity = getBaseMetaTileEntity().getTileEntityAtSide(i);
+			if (!aAlreadyPassedTileEntityList.contains(tTileEntity)) {
+				aAlreadyPassedTileEntityList.add(tTileEntity);
+				if (tTileEntity instanceof IEnergyConnected) {
+					if (getBaseMetaTileEntity().getColorization() >= 0) {
+						byte tColor = ((IEnergyConnected)tTileEntity).getColorization();
+						if (tColor >= 0 && tColor != getBaseMetaTileEntity().getColorization()) continue;
+					}
+					if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable && ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(GT_Utility.getOppositeSide(i)).letsEnergyIn(GT_Utility.getOppositeSide(i), ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(GT_Utility.getOppositeSide(i)), ((IGregTechTileEntity)tTileEntity))) {
+						if (((IGregTechTileEntity)tTileEntity).getTimer() > 50) rUsedAmperes += ((IMetaTileEntityCable)((IGregTechTileEntity)tTileEntity).getMetaTileEntity()).transferElectricity(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes, aAlreadyPassedTileEntityList);
+					} else {
+						rUsedAmperes += ((IEnergyConnected)tTileEntity).injectEnergyUnits(GT_Utility.getOppositeSide(i), aVoltage, aAmperage-rUsedAmperes);
+					}
+					//        		} else if (tTileEntity instanceof IEnergySink) {
+					//            		ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					//            		if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+					//            			if (((IEnergySink)tTileEntity).demandedEnergyUnits() > 0 && ((IEnergySink)tTileEntity).injectEnergyUnits(tDirection, aVoltage) < aVoltage) rUsedAmperes++;
+					//            		}
+				} else if (tTileEntity instanceof IEnergySink) {
+					ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					if (((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)getBaseMetaTileEntity(), tDirection)) {
+						if (((IEnergySink)tTileEntity).getDemandedEnergy() > 0 && ((IEnergySink)tTileEntity).injectEnergy(tDirection, aVoltage, aVoltage) < aVoltage) rUsedAmperes++;
+					}
+				} else if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver){
+					ForgeDirection tDirection = ForgeDirection.getOrientation(i).getOpposite();
+					int rfOut = (int) (aVoltage * GregTech_API.mEUtoRF / 100);
+					if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)==rfOut){
+						((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, false); rUsedAmperes++;
+					}else if(((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, rfOut, true)>0){
+						if(mRestRF==0){
+							int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) rfOut, false);rUsedAmperes++;
+							mRestRF = rfOut - RFtrans; 
+						}else{
+							int RFtrans = ((IEnergyReceiver)tTileEntity).receiveEnergy(tDirection, (int) mRestRF, false); 
+							mRestRF = mRestRF - RFtrans;
+						}
+					}
+					if(GregTech_API.mRFExplosions && ((IEnergyReceiver)tTileEntity).getMaxEnergyStored(tDirection) < rfOut * 600){
+						if(rfOut > 32 * GregTech_API.mEUtoRF / 100) this.doExplosion(rfOut);
+					}
+				}
+			}
+		}
+		mTransferredAmperage += rUsedAmperes;
+		mTransferredVoltageLast20 = Math.max(mTransferredVoltageLast20, aVoltage);
+		mTransferredAmperageLast20 = Math.max(mTransferredAmperageLast20, mTransferredAmperage);
+		if (aVoltage > mVoltage || mTransferredAmperage > mAmperage) {
+			getBaseMetaTileEntity().setToFire();
+			return aAmperage;
+		}
+		return rUsedAmperes;
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		if (aBaseMetaTileEntity.isServerSide()) {
+			mTransferredAmperage = 0;
+
+			if (aTick % 20 == 0) {
+				mTransferredVoltageLast20 = 0;
+				mTransferredAmperageLast20 = 0;
+				mConnections = 0;
+				for (byte i = 0, j = 0; i < 6; i++) {
+					j = GT_Utility.getOppositeSide(i);
+					if (aBaseMetaTileEntity.getCoverBehaviorAtSide(i).alwaysLookConnected(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyIn(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity) || aBaseMetaTileEntity.getCoverBehaviorAtSide(i).letsEnergyOut(i, aBaseMetaTileEntity.getCoverIDAtSide(i), aBaseMetaTileEntity.getCoverDataAtSide(i), aBaseMetaTileEntity)) {
+						TileEntity tTileEntity = aBaseMetaTileEntity.getTileEntityAtSide(i);
+						if (tTileEntity instanceof IColoredTileEntity) {
+							if (aBaseMetaTileEntity.getColorization() >= 0) {
+								byte tColor = ((IColoredTileEntity)tTileEntity).getColorization();
+								if (tColor >= 0 && tColor != aBaseMetaTileEntity.getColorization()) continue;
+							}
+						}
+						if (tTileEntity instanceof IEnergyConnected && (((IEnergyConnected)tTileEntity).inputEnergyFrom(j) || ((IEnergyConnected)tTileEntity).outputsEnergyTo(j))) {
+							mConnections |= (1<<i);
+							continue;
+						}
+						if (tTileEntity instanceof IGregTechTileEntity && ((IGregTechTileEntity)tTileEntity).getMetaTileEntity() instanceof IMetaTileEntityCable) {
+							if (((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).alwaysLookConnected(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity)) || ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).letsEnergyIn(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity)) || ((IGregTechTileEntity)tTileEntity).getCoverBehaviorAtSide(j).letsEnergyOut(j, ((IGregTechTileEntity)tTileEntity).getCoverIDAtSide(j), ((IGregTechTileEntity)tTileEntity).getCoverDataAtSide(j), ((IGregTechTileEntity)tTileEntity))) {
+								mConnections |= (1<<i);
+								continue;
+							}
+						}
+						if (tTileEntity instanceof IEnergySink && ((IEnergySink)tTileEntity).acceptsEnergyFrom((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+							mConnections |= (1<<i);
+							continue;
+						}
+						if(GregTech_API.mOutputRF && tTileEntity instanceof IEnergyReceiver && ((IEnergyReceiver)tTileEntity).canConnectEnergy(ForgeDirection.getOrientation(j))){
+							mConnections |= (1<<i);
+							continue;					    	
+						}					    
+						/*
+					    if (tTileEntity instanceof IEnergyEmitter && ((IEnergyEmitter)tTileEntity).emitsEnergyTo((TileEntity)aBaseMetaTileEntity, ForgeDirection.getOrientation(j))) {
+				    		mConnections |= (1<<i);
+				    		continue;
+					    }*/
+					}
+				}
+			}
+		}
+	}
+
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {
+				"Max Voltage: "			+ EnumChatFormatting.GREEN	+ mVoltage + " (" + VN[GT_Utility.getTier(mVoltage)]	+ ")" + EnumChatFormatting.GRAY,
+				"Max Amperage: "		+ EnumChatFormatting.YELLOW	+ mAmperage + EnumChatFormatting.GRAY,
+				"Loss/Meter/Ampere: "	+ EnumChatFormatting.RED	+ mCableLossPerMeter + EnumChatFormatting.GRAY + " EU-Volt",
+				CORE.GT_Tooltip,
+				" ",
+				"This Wire is Lossless.",
+				"Please, adhere to cooling directions."
+		};
+	}
+
+
+	@Override
+	public float getThickNess() {
+		return mThickNess;
+	}
+
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java
index 37c57be0e6..abe5832a9e 100644
--- a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSafeBlock.java
@@ -9,7 +9,7 @@ import gregtech.api.util.GT_Utility;
 import miscutil.core.lib.CORE;
 import miscutil.core.xmod.gregtech.api.gui.CONTAINER_SafeBlock;
 import miscutil.core.xmod.gregtech.api.gui.GUI_SafeBlock;
-import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaSafeBlockBase;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.machines.GregtechMetaSafeBlockBase;
 import net.minecraft.entity.player.InventoryPlayer;
 
 public class GregtechMetaSafeBlock
diff --git a/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java
new file mode 100644
index 0000000000..0c37078646
--- /dev/null
+++ b/src/Java/miscutil/core/xmod/gregtech/api/metatileentity/implementations/GregtechMetaSuperConductorNodeBase.java
@@ -0,0 +1,297 @@
+package miscutil.core.xmod.gregtech.api.metatileentity.implementations;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Recipe.GT_Recipe_Map;
+import gregtech.api.util.GT_Utility;
+
+import java.util.Collection;
+
+import miscutil.core.lib.CORE;
+import miscutil.core.xmod.gregtech.api.metatileentity.implementations.base.lossless.GregtechMetaTileEntityLosslessBasicTank;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.fluids.FluidStack;
+
+public abstract class GregtechMetaSuperConductorNodeBase extends GregtechMetaTileEntityLosslessBasicTank {
+    public GregtechMetaSuperConductorNodeBase(int aID, String aName, String aNameRegional, int aTier, String aDescription, ITexture... aTextures) {
+        super(aID, aName, aNameRegional, aTier, 3, aDescription, aTextures);
+    }
+
+    public GregtechMetaSuperConductorNodeBase(String aName, int aTier, String aDescription, ITexture[][][] aTextures) {
+        super(aName, aTier, 3, aDescription, aTextures);
+    }
+
+    @Override
+    public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+        ITexture[][][] rTextures = new ITexture[10][17][];
+        for (byte i = -1; i < 16; i++) {
+            rTextures[0][i + 1] = getFront(i);
+            rTextures[1][i + 1] = getBack(i);
+            rTextures[2][i + 1] = getBottom(i);
+            rTextures[3][i + 1] = getTop(i);
+            rTextures[4][i + 1] = getSides(i);
+            rTextures[5][i + 1] = getFrontActive(i);
+            rTextures[6][i + 1] = getBackActive(i);
+            rTextures[7][i + 1] = getBottomActive(i);
+            rTextures[8][i + 1] = getTopActive(i);
+            rTextures[9][i + 1] = getSidesActive(i);
+        }
+        return rTextures;
+    }
+
+    @Override
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        return mTextures[(aActive ? 5 : 0) + (aSide == aFacing ? 0 : aSide == GT_Utility.getOppositeSide(aFacing) ? 1 : aSide == 0 ? 2 : aSide == 1 ? 3 : 4)][aColorIndex + 1];
+    }
+
+    @Override
+    public String[] getDescription() {
+        return new String[]{mDescription, "Cooling Efficiency: " + getEfficiency() + "%", CORE.GT_Tooltip};
+    }
+
+    @Override
+    public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+        if (aBaseMetaTileEntity.isClientSide()) return true;
+        aBaseMetaTileEntity.openGUI(aPlayer);
+        return true;
+    }
+
+    public ITexture[] getFront(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBack(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getBottom(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getTop(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getSides(byte aColor) {
+        return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][aColor + 1]};
+    }
+
+    public ITexture[] getFrontActive(byte aColor) {
+        return getFront(aColor);
+    }
+
+    public ITexture[] getBackActive(byte aColor) {
+        return getBack(aColor);
+    }
+
+    public ITexture[] getBottomActive(byte aColor) {
+        return getBottom(aColor);
+    }
+
+    public ITexture[] getTopActive(byte aColor) {
+        return getTop(aColor);
+    }
+
+    public ITexture[] getSidesActive(byte aColor) {
+        return getSides(aColor);
+    }
+
+    @Override
+    public boolean isFacingValid(byte aSide) {
+        return aSide > 1;
+    }
+
+    @Override
+    public boolean isSimpleMachine() {
+        return false;
+    }
+
+    @Override
+    public boolean isValidSlot(int aIndex) {
+        return aIndex < 2;
+    }
+    
+    @Override
+    public boolean isEnetInput() {
+        return true;
+    }
+
+    @Override
+    public boolean isEnetOutput() {
+        return true;
+    }
+
+    @Override
+    public boolean isOutputFacing(byte aSide) {
+        return true;
+    }
+
+    @Override
+    public boolean isAccessAllowed(EntityPlayer aPlayer) {
+        return true;
+    }
+    
+    @Override
+    public long getMinimumStoredEU() {
+        return V[mTier] * 16 * mInventory.length;
+    }
+
+    @Override
+    public long maxEUStore() {
+        return V[mTier] * 64;
+    }
+
+    @Override
+    public long maxEUInput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxEUOutput() {
+        return V[mTier];
+    }
+
+    @Override
+    public long maxAmperesIn() {
+        return 16;
+    }
+
+    @Override
+    public long maxAmperesOut() {
+        return 16;
+    }
+
+    @Override
+    public boolean doesFillContainers() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean doesEmptyContainers() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean canTankBeFilled() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean canTankBeEmptied() {
+        return getBaseMetaTileEntity().isAllowedToWork();
+    }
+
+    @Override
+    public boolean displaysItemStack() {
+        return true;
+    }
+
+    @Override
+    public boolean displaysStackSize() {
+        return false;
+    }
+
+    @Override
+    public boolean isFluidInputAllowed(FluidStack aFluid) {
+        return getFuelValue(aFluid) > 0;
+    }
+
+    @Override
+    public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+    	if (getEUVar() == maxEUStore() || mFluid == null){
+    		aBaseMetaTileEntity.disableWorking();
+    	}
+    	else {
+    		aBaseMetaTileEntity.enableWorking();            		
+    	}
+        if (aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isAllowedToWork() && aTick % 10 == 0) {
+            if (mFluid == null) {
+                if (aBaseMetaTileEntity.getUniversalEnergyStored() < maxEUOutput() + getMinimumStoredEU()) {
+                    mInventory[getStackDisplaySlot()] = null;
+                } else {
+                    if (mInventory[getStackDisplaySlot()] == null)
+                        mInventory[getStackDisplaySlot()] = new ItemStack(Blocks.fire, 1);
+                    mInventory[getStackDisplaySlot()].setStackDisplayName("Generating: " + (aBaseMetaTileEntity.getUniversalEnergyStored() - getMinimumStoredEU()) + " EU");
+                }
+            } else {            	
+                int tFuelValue = getFuelValue(mFluid), tConsumed = consumedFluidPerOperation(mFluid);
+                if (tConsumed > 0 && mFluid.amount > tConsumed) {
+                    long tFluidAmountToUse = Math.min(mFluid.amount / tConsumed, (maxEUOutput() * 20 + getMinimumStoredEU() - aBaseMetaTileEntity.getUniversalEnergyStored()));
+                    if (tFluidAmountToUse > 0 /*&& aBaseMetaTileEntity.increaseStoredEnergyUnits(tFluidAmountToUse * tFuelValue, true)*/)
+                        mFluid.amount -= tFluidAmountToUse * tConsumed;
+                }
+            }
+            if (mInventory[getInputSlot()] != null && aBaseMetaTileEntity.getUniversalEnergyStored() < (maxEUOutput() * 20 + getMinimumStoredEU()) && GT_Utility.getFluidForFilledItem(mInventory[getInputSlot()], true) == null) {
+                int tFuelValue = getFuelValue(mInventory[getInputSlot()]);
+                if (tFuelValue >= 0) {
+                    ItemStack tEmptyContainer = getEmptyContainer(mInventory[getInputSlot()]);
+                    if (aBaseMetaTileEntity.addStackToSlot(getOutputSlot(), tEmptyContain