+ Attempted to add custom IC2 generators.

% Refactored the xmod package to be a parent, beside core. No longer is it a child, it needs room to grow.

20 files changed, 7696 insertions, 0 deletions

diff --git a/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
new file mode 100644
index 0000000000..0a21655308
--- /dev/null
+++ b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaCondensor.java
@@ -0,0 +1,165 @@
+package miscutil.xmod.gregtech.api.metatileentity.implementations;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Textures;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.MetaTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import miscutil.core.lib.CORE;
+import miscutil.core.util.Utils;
+import miscutil.core.util.math.MathUtils;
+import miscutil.xmod.gregtech.api.gui.CONTAINER_SteamCondenser;
+import miscutil.xmod.gregtech.api.gui.GUI_SteamCondenser;
+import miscutil.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;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class GregtechMetaCondensor extends GregtechMetaBoilerBase{
+
+	 public GregtechMetaCondensor(int aID, String aName, String aNameRegional)
+	  {
+	    super(aID, aName, aNameRegional, "A Steam condenser - [IC2->Steam]", new ITexture[0]);
+	  }
+	  
+	  public GregtechMetaCondensor(String aName, int aTier, String aDescription, ITexture[][][] aTextures)
+	  {
+	    super(aName, aTier, aDescription, aTextures);
+	  }
+	  
+	  @Override
+		public String[] getDescription() {
+			return new String[] {mDescription, CORE.GT_Tooltip};
+		}
+	  
+	  public ITexture[][][] getTextureSet(ITexture[] aTextures)
+	  {
+	    ITexture[][][] rTextures = new ITexture[5][17][];
+	    for (byte i = -1; i < 16; i++){
+	      rTextures[0][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_VENT, Dyes.getModulation(i, Dyes.MACHINE_METAL.mRGBa))};
+	      rTextures[1][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_VENT, Dyes.getModulation(i, Dyes.MACHINE_METAL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) };
+	      rTextures[2][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_VENT, Dyes.getModulation(i, Dyes.MACHINE_METAL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) };
+	      rTextures[3][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_VENT, Dyes.getModulation(i, Dyes.MACHINE_METAL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_POTIONBREWER) };
+	      rTextures[4][(i + 1)] = new ITexture [] { new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_VENT, Dyes.getModulation(i, Dyes.MACHINE_METAL.mRGBa)), new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_FRONT_POTIONBREWER_ACTIVE) };
+	    }
+	    return rTextures;
+	  }
+	  
+	  public int maxProgresstime()
+	  {
+	    return 1000;
+	  }
+	  
+	  public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity)
+	  {
+	    return new CONTAINER_SteamCondenser(aPlayerInventory, aBaseMetaTileEntity, 32000);
+	  }
+	  
+	  public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity)
+	  {
+	    return new GUI_SteamCondenser(aPlayerInventory, aBaseMetaTileEntity, "SteelBoiler.png", 32000);
+	  }
+	  
+	  public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity)
+	  {
+	    return new GregtechMetaCondensor(this.mName, this.mTier, this.mDescription, this.mTextures);
+	  }
+	  
+	  public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick)
+	  {
+		  this.RI = MathUtils.randLong(5L, 30L);
+	    if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L))
+	    {
+	      if (this.mTemperature <= 5)
+	      {
+	        this.mTemperature = 5;
+	        this.mLossTimer = 0;
+	      }
+	      if (++this.mLossTimer > 10)
+	      {
+	        this.mTemperature -= 1;
+	        this.mLossTimer = 0;
+	      }
+	      for (byte i = 1; (this.mSteam != null) && (i < 6); i = (byte)(i + 1)) {
+	        if (i != aBaseMetaTileEntity.getFrontFacing())
+	        {
+	          IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i);
+	          if (tTileEntity != null)
+	          {
+	            FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false);
+	            if (tDrained != null)
+	            {
+	              int tFilledAmount = tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), tDrained, false);
+	              if (tFilledAmount > 0) {
+	                tTileEntity.fill(ForgeDirection.getOrientation(i).getOpposite(), aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), tFilledAmount, true), true);
+	              }
+	            }
+	          }
+	        }
+	      }
+	      if (aTick % 10L == 0L) {
+	        if (this.mTemperature > 5)
+	        {
+	          if ((this.mFluid == null) || (!GT_ModHandler.isWater(this.mFluid)) || (this.mFluid.amount <= 0))
+	          {
+	            this.mHadNoWater = true;
+	          }
+	          else
+	          {
+	            if (this.mHadNoWater)
+	            {
+	              aBaseMetaTileEntity.doExplosion(2048L);
+	              return;
+	            }
+	            this.mFluid.amount -= 1;
+	            if (this.mSteam == null) {
+	              this.mSteam = GT_ModHandler.getSteam(30L);
+	            } else if (GT_ModHandler.isSteam(this.mSteam)) {
+	              this.mSteam.amount += 30;
+	            } else {
+	              this.mSteam = GT_ModHandler.getSteam(30L);
+	            }
+	          }
+	        }
+	        else {
+	          this.mHadNoWater = false;
+	        }
+	      }
+	      if ((this.mSteam != null) && 
+	        (this.mSteam.amount > 32000))
+	      {
+	        sendSound((byte)1);
+	        this.mSteam.amount = 24000;
+	      }
+	      /*if ((this.mProcessingEnergy <= 0) && (aBaseMetaTileEntity.isAllowedToWork()) && 
+	        (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.bucket.get(IC2.getItemFromBlock(p_150898_0_)))))
+	      {
+	        this.mProcessingEnergy += 1000;
+	        aBaseMetaTileEntity.decrStackSize(2, 1);
+	        aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.bucket, Materials.Empty, 1L));
+	      }*/	      
+	      if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % RI == 0L))
+	      {
+	        this.mProcessingEnergy -= 40;
+	        this.mTemperature += 2;
+	      }
+	      aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0);
+	    }
+	  }
+	  
+	  public final int fill(FluidStack aFluid, boolean doFill)
+	  {
+	    if ((Utils.isIC2Steam(aFluid)) && (this.mProcessingEnergy < 50))
+	    {
+	      int tFilledAmount = Math.min(50, aFluid.amount);
+	      if (doFill) {
+	        this.mProcessingEnergy += tFilledAmount;
+	      }
+	      return tFilledAmount;
+	    }
+	    return super.fill(aFluid, doFill);
+	  }
+}
diff --git a/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaEnergyBuffer.java b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaEnergyBuffer.java
new file mode 100644
index 0000000000..7647dd3a5a
--- /dev/null
+++ b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaEnergyBuffer.java
@@ -0,0 +1,338 @@
+package miscutil.xmod.gregtech.api.metatileentity.implementations;
+
+import static gregtech.api.enums.GT_Values.V;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_Container_1by1;
+import gregtech.api.gui.GT_GUIContainer_1by1;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.items.GT_MetaBase_Item;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_Utility;
+import ic2.api.item.IElectricItem;
+import miscutil.core.lib.CORE;
+import miscutil.core.util.Utils;
+import miscutil.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaTileEntity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+public class GregtechMetaEnergyBuffer extends GregtechMetaTileEntity {
+
+	/*
+	 * public GregtechMetaEnergyBuffer() { super.this
+	 * setCreativeTab(GregTech_API.TAB_GREGTECH); }
+	 */
+
+	public boolean mCharge = false, mDecharge = false;
+	public int mBatteryCount = 1, mChargeableCount = 1;
+
+	public GregtechMetaEnergyBuffer(int aID, String aName, String aNameRegional, int aTier, String aDescription, int aSlotCount) {
+		super(aID, aName, aNameRegional, aTier, aSlotCount, aDescription);
+	}
+
+	public GregtechMetaEnergyBuffer(String aName, int aTier, String aDescription, ITexture[][][] aTextures, int aSlotCount) {
+		super(aName, aTier, aSlotCount, aDescription, aTextures);
+	}
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {mDescription, CORE.GT_Tooltip};
+	}
+
+	/*
+	 * MACHINE_STEEL_SIDE
+	 */
+	@Override
+	public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+		ITexture[][][] rTextures = new ITexture[2][17][];
+		for (byte i = -1; i < 16; i++) {
+			rTextures[0][i + 1] = new ITexture[] { new GT_RenderedTexture(
+					Textures.BlockIcons.MACHINE_HEATPROOFCASING) };
+			rTextures[1][i + 1] = new ITexture[] {
+					new GT_RenderedTexture(
+							Textures.BlockIcons.MACHINE_HEATPROOFCASING),
+							mInventory.length > 4 ? Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[mTier]
+									: Textures.BlockIcons.OVERLAYS_ENERGY_OUT[mTier] };
+		}
+		return rTextures;
+	}
+
+	/*
+	 * @Override public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+	 * ITexture[][][] rTextures = new ITexture[5][17][]; for (byte i = -1; i <
+	 * 16; i = (byte) (i + 1)) { ITexture[] tmp0 = { new GT_RenderedTexture(
+	 * Textures.BlockIcons.MACHINE_STEEL_BOTTOM, Dyes.getModulation(i,
+	 * Dyes._NULL.mRGBa)) }; rTextures[0][(i + 1)] = tmp0; ITexture[] tmp1 = {
+	 * new GT_RenderedTexture( Textures.BlockIcons.MACHINE_STEEL_TOP) };
+	 * rTextures[1][(i + 1)] = tmp1; ITexture[] tmp2 = { new GT_RenderedTexture(
+	 * Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i,
+	 * Dyes._NULL.mRGBa)), new
+	 * GT_RenderedTexture(Textures.BlockIcons.OVERLAY_PIPE) }; rTextures[2][(i +
+	 * 1)] = tmp2; ITexture[] tmp4 = { new GT_RenderedTexture(
+	 * Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i,
+	 * Dyes._NULL.mRGBa)), new
+	 * GT_RenderedTexture(Textures.BlockIcons.BOILER_FRONT) }; rTextures[3][(i +
+	 * 1)] = tmp4; ITexture[] tmp5 = { new GT_RenderedTexture(
+	 * Textures.BlockIcons.MACHINE_STEEL_SIDE, Dyes.getModulation(i,
+	 * Dyes._NULL.mRGBa)), new GT_RenderedTexture(
+	 * Textures.BlockIcons.BOILER_FRONT_ACTIVE) }; rTextures[4][(i + 1)] = tmp5;
+	 * } return rTextures; }
+	 */
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		return mTextures[aSide == aFacing ? 1 : 0][aColorIndex+1];
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaEnergyBuffer(mName, mTier, mDescription, mTextures, mInventory.length);
+	}
+
+	@Override public boolean isSimpleMachine()						{return false;}
+	@Override public boolean isElectric()							{return true;}
+	@Override public boolean isValidSlot(int aIndex)				{return true;}
+	@Override public boolean isFacingValid(byte aFacing)			{return true;}
+	@Override public boolean isEnetInput() 							{return true;}
+	@Override public boolean isEnetOutput() 						{return true;}
+	@Override public boolean isInputFacing(byte aSide)				{return aSide!=getBaseMetaTileEntity().getFrontFacing();}
+	@Override public boolean isOutputFacing(byte aSide)				{return aSide==getBaseMetaTileEntity().getFrontFacing();}
+	@Override public boolean isTeleporterCompatible()				{return false;}
+	@Override public long getMinimumStoredEU()						{return V[mTier]*2;}
+	@Override public long maxEUStore()								{return V[mTier]*250000;}
+
+	@Override
+	public long maxEUInput() {
+		return V[mTier];
+	}
+
+	@Override
+	public long maxEUOutput() {
+		return V[mTier];
+	}
+
+	@Override
+	public long maxAmperesIn() {
+		return mChargeableCount * 4;
+	}
+
+	@Override
+	public long maxAmperesOut() {
+		return mChargeableCount * 4;
+	}
+	@Override public int rechargerSlotStartIndex()					{return 0;}
+	@Override public int dechargerSlotStartIndex()					{return 0;}
+	@Override public int rechargerSlotCount()						{return mCharge?mInventory.length:0;}
+	@Override public int dechargerSlotCount()						{return mDecharge?mInventory.length:0;}
+	@Override public int getProgresstime()							{return (int)getBaseMetaTileEntity().getUniversalEnergyStored();}
+	@Override public int maxProgresstime()							{return (int)getBaseMetaTileEntity().getUniversalEnergyCapacity();}
+	@Override public boolean isAccessAllowed(EntityPlayer aPlayer)	{return true;}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		//
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		//
+	}
+
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+		Utils.LOG_WARNING("Right Click on MTE by Player");
+		if (aBaseMetaTileEntity.isClientSide()) return true;
+		//aBaseMetaTileEntity.openGUI(aPlayer);
+
+		Utils.LOG_WARNING("MTE is Client-side");
+		showEnergy(aPlayer.getEntityWorld(), aPlayer);  
+		return true;
+	}
+
+	private void showEnergy(World worldIn, EntityPlayer playerIn){
+		long tempStorage = getStoredEnergy()[0];		
+		final double c = ((double) tempStorage / maxEUStore()) * 100;
+		final double roundOff = Math.round(c * 100.00) / 100.00;
+		Utils.messagePlayer(playerIn, "Energy: " + tempStorage + " EU at "+V[mTier]+"v ("+roundOff+"%)");
+
+	}
+		//Utils.LOG_WARNING("Begin Show Energy");
+		/*
+		 * 
+		//Utils.LOG_INFO("getProgresstime: "+tempStorage+"  maxProgresstime: "+maxEUStore()+"  C: "+c);
+				Utils.LOG_INFO("getProgressTime: "+getProgresstime());
+				Utils.LOG_INFO("maxProgressTime: "+maxProgresstime());
+				Utils.LOG_INFO("getMinimumStoredEU: "+getMinimumStoredEU());
+				Utils.LOG_INFO("maxEUStore: "+maxEUStore());*/
+		/*final long d = (tempStorage * 100L) / maxEUStore();
+		Utils.LOG_INFO("getProgresstime: "+tempStorage+"  maxProgresstime: "+maxEUStore()+"  D: "+d);
+		final double roundOff2 = Math.round(d * 100.00) / 100.00;
+		Utils.messagePlayer(playerIn, "Energy: " + tempStorage + " EU at "+V[mTier]+"v ("+roundOff2+"%)");
+		Utils.LOG_WARNING("Making new instance of Guihandler");
+		GuiHandler block = new GuiHandler();
+		Utils.LOG_WARNING("Guihandler.toString(): "+block.toString());
+		block.getClientGuiElement(1, playerIn, worldIn, (int) playerIn.posX, (int) playerIn.posY, (int) playerIn.posZ);*/
+
+
+	@Override
+	public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_Container_1by1(aPlayerInventory, aBaseMetaTileEntity);
+	}
+
+	@Override
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_1by1(aPlayerInventory, aBaseMetaTileEntity, getLocalName());
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		
+	}
+
+	@Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return false;
+	}
+
+	public long[] getStoredEnergy(){
+		long tScale = getBaseMetaTileEntity().getEUCapacity();
+		long tStored = getBaseMetaTileEntity().getStoredEU();
+		if (mInventory != null) {
+			for (ItemStack aStack : mInventory) {
+				if (GT_ModHandler.isElectricItem(aStack)) {
+
+					if (aStack.getItem() instanceof GT_MetaBase_Item) {
+						Long[] stats = ((GT_MetaBase_Item) aStack.getItem())
+								.getElectricStats(aStack);
+						if (stats != null) {
+							tScale = tScale + stats[0];
+							tStored = tStored
+									+ ((GT_MetaBase_Item) aStack.getItem())
+									.getRealCharge(aStack);
+						}
+					} else if (aStack.getItem() instanceof IElectricItem) {
+						tStored = tStored
+								+ (long) ic2.api.item.ElectricItem.manager
+								.getCharge(aStack);
+						tScale = tScale
+								+ (long) ((IElectricItem) aStack.getItem())
+								.getMaxCharge(aStack);
+					}
+				}
+			}
+
+		}
+		return new long[] { tStored, tScale };
+	}
+
+	private long count=0;
+	private long mStored=0;
+	private long mMax=0;
+
+	@Override
+	public String[] getInfoData() {
+		count++;
+		if(mMax==0||count%20==0){
+			long[] tmp = getStoredEnergy();
+			mStored=tmp[0];
+			mMax=tmp[1];
+		}
+
+		return new String[] {
+				getLocalName(),
+				GT_Utility.formatNumbers(mStored)+" EU /",
+				GT_Utility.formatNumbers(mMax)+" EU"};
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(int p_94128_1_) {
+		return null;
+	}
+
+	@Override
+	public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_, int p_102007_3_) {
+		return false;
+	}
+
+	@Override
+	public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_, int p_102008_3_) {
+		return false;
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(int p_70301_1_) {
+		return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_) {
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(int p_70304_1_) {
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) {
+	}
+
+	@Override
+	public String getInventoryName() {
+		return null;
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return false;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return 0;
+	}
+
+	@Override
+	public void markDirty() {
+	}
+
+	@Override
+	public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
+		return false;
+	}
+
+	@Override
+	public void openInventory() {
+	}
+
+	@Override
+	public void closeInventory() {
+	}
+
+	@Override
+	public boolean isItemValidForSlot(int p_94041_1_, ItemStack p_94041_2_) {
+		return false;
+	}
+
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java
new file mode 100644
index 0000000000..528bd8db85
--- /dev/null
+++ b/src/Java/miscutil/xmod/gregtech/api/metatileentity/implementations/GregtechMetaPipeEntity_Cable.java
@@ -0,0 +1,236 @@
+package miscutil.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.Materials;
+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.metatileentity.implementations.GT_MetaPipeEntity_Cable;
+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 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_Cable extends GT_MetaPipeEntity_Cable implements IMetaTileEntityCable {
+	public long mTransferredAmperage = 0, mTransferredAmperageLast20 = 0, mTransferredVoltageLast20 = 0;
+
+	public final float mThickNess;
+	public final Materials mMaterial;
+	public final long mCableLossPerMeter, mAmperage, mVoltage;
+	public final boolean mInsulated, mCanShock;
+	public long mRestRF;
+
+	public GregtechMetaPipeEntity_Cable(int aID, String aName, String aNameRegional, float aThickNess, Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aID, aName, aNameRegional, 0, aMaterial, aCableLossPerMeter, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = aCableLossPerMeter;
+	}
+
+	public GregtechMetaPipeEntity_Cable(String aName, float aThickNess, Materials aMaterial, long aCableLossPerMeter, long aAmperage, long aVoltage, boolean aInsulated, boolean aCanShock) {
+		super(aName, 0, aMaterial, aCableLossPerMeter, aAmperage, aVoltage, aInsulated, aCanShock);
+		mThickNess = aThickNess;
+		mMaterial = aMaterial;
+		mAmperage = aAmperage;
+		mVoltage = aVoltage;
+		mInsulated = aInsulated;
+		mCanShock = aCanShock;
+		mCableLossPerMeter = aCableLossPerMeter;
+	}
+
+	@Override
+	public byte getTileEntityBaseType() {
+		return (byte)(mInsulated?9:8);
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaPipeEntity_Cable(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);
+					}
+				}