Refactoring like a champion.

4 files changed, 1028 insertions, 0 deletions

diff --git a/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java
new file mode 100644
index 0000000000..12e807bc34
--- /dev/null
+++ b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaBoilerBase.java
@@ -0,0 +1,328 @@
+package miscutil.gregtech.api.metatileentity.implementations.base;
+
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_BasicTank;
+import gregtech.api.objects.GT_ItemStack;
+import gregtech.api.util.GT_ModHandler;
+import gregtech.api.util.GT_OreDictUnificator;
+import gregtech.api.util.GT_Utility;
+import miscutil.core.util.Utils;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public abstract class GregtechMetaBoilerBase  extends GT_MetaTileEntity_BasicTank
+{
+  public int mTemperature = 20;
+  public int mProcessingEnergy = 0;
+  public int mLossTimer = 0;
+  public FluidStack mSteam = null;
+  public boolean mHadNoWater = false;
+  public long RI = Utils.randLong(5L, 30L);
+  
+  public GregtechMetaBoilerBase(int aID, String aName, String aNameRegional, String aDescription, ITexture... aTextures)
+  {
+    super(aID, aName, aNameRegional, 0, 4, aDescription, aTextures);
+  }
+  
+  public GregtechMetaBoilerBase(String aName, int aTier, String aDescription, ITexture[][][] aTextures)
+  {
+    super(aName, aTier, 4, aDescription, aTextures);
+  }
+  
+  public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone)
+  {
+	  ITexture[] tmp = mTextures[aSide >= 2 ? aSide != aFacing ? 2 : ((byte)(aActive ? 4 : 3)) : aSide][aColorIndex + 1];
+			  //mTextures[(aSide==aFacing?(aActive?4:3):aSide==GT_Utility.getOppositeSide(aFacing)?2:aSide==0?0:aSide==1?1:2)][aColorIndex+1];
+	  if(aSide!=aFacing&&tmp.length==2){
+			  tmp = new ITexture[]{tmp[0]};
+	  }
+	  return tmp;
+  }
+  
+  public boolean isElectric()
+  {
+    return false;
+  }
+  
+  public boolean isPneumatic()
+  {
+    return false;
+  }
+  
+  public boolean isSteampowered()
+  {
+    return false;
+  }
+  
+  public boolean isSimpleMachine()
+  {
+    return false;
+  }
+  
+  public boolean isFacingValid(byte aFacing)
+  {
+    return aFacing > 1;
+  }
+  
+  public boolean isAccessAllowed(EntityPlayer aPlayer)
+  {
+    return true;
+  }
+  
+  public boolean isValidSlot(int aIndex)
+  {
+    return true;
+  }
+  
+  public int getProgresstime()
+  {
+    return this.mTemperature;
+  }
+  
+  public int maxProgresstime()
+  {
+    return 500;
+  }
+  
+  public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer)
+  {
+    if (aBaseMetaTileEntity.isClientSide()) {
+      return true;
+    }
+    if (aPlayer != null) {
+      if (GT_Utility.areStacksEqual(aPlayer.getCurrentEquippedItem(), new ItemStack(Items.water_bucket, 1)))
+      {
+        fill(Materials.Water.getFluid(1000 * aPlayer.getCurrentEquippedItem().stackSize), true);
+        aPlayer.getCurrentEquippedItem().func_150996_a(Items.bucket);
+      }
+      else
+      {
+        aBaseMetaTileEntity.openGUI(aPlayer);
+      }
+    }
+    return true;
+  }
+  
+  public boolean doesFillContainers()
+  {
+    return true;
+  }
+  
+  public boolean doesEmptyContainers()
+  {
+    return true;
+  }
+  
+  public boolean canTankBeFilled()
+  {
+    return true;
+  }
+  
+  public boolean canTankBeEmptied()
+  {
+    return true;
+  }
+  
+  public boolean displaysItemStack()
+  {
+    return false;
+  }
+  
+  public boolean displaysStackSize()
+  {
+    return false;
+  }
+  
+  public boolean isFluidInputAllowed(FluidStack aFluid)
+  {
+    return GT_ModHandler.isWater(aFluid);
+  }
+  
+  public FluidStack getDrainableStack()
+  {
+    return this.mSteam;
+  }
+  
+  public FluidStack setDrainableStack(FluidStack aFluid)
+  {
+    this.mSteam = aFluid;return this.mSteam;
+  }
+  
+  public boolean allowCoverOnSide(byte aSide, GT_ItemStack aCover)
+  {
+    return GregTech_API.getCoverBehavior(aCover.toStack()).isSimpleCover();
+  }
+  
+  public void saveNBTData(NBTTagCompound aNBT)
+  {
+    super.saveNBTData(aNBT);
+    aNBT.setInteger("mLossTimer", this.mLossTimer);
+    aNBT.setInteger("mTemperature", this.mTemperature);
+    aNBT.setInteger("mProcessingEnergy", this.mProcessingEnergy);
+    if (this.mSteam != null) {
+      try
+      {
+        aNBT.setTag("mSteam", this.mSteam.writeToNBT(new NBTTagCompound()));
+      }
+      catch (Throwable e) {}
+    }
+  }
+  
+  public void loadNBTData(NBTTagCompound aNBT)
+  {
+    super.loadNBTData(aNBT);
+    this.mLossTimer = aNBT.getInteger("mLossTimer");
+    this.mTemperature = aNBT.getInteger("mTemperature");
+    this.mProcessingEnergy = aNBT.getInteger("mProcessingEnergy");
+    this.mSteam = FluidStack.loadFluidStackFromNBT(aNBT.getCompoundTag("mSteam"));
+  }
+  
+  public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick)
+  {
+    if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L))
+    {
+      if (this.mTemperature <= 20)
+      {
+        this.mTemperature = 20;
+        this.mLossTimer = 0;
+      }
+      if (++this.mLossTimer > 40)
+      {
+        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 > 100)
+        {
+          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(150L);
+            } else if (GT_ModHandler.isSteam(this.mSteam)) {
+              this.mSteam.amount += 150;
+            } else {
+              this.mSteam = GT_ModHandler.getSteam(150L);
+            }
+          }
+        }
+        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()) && 
+        (this.mInventory[2] != null)) {
+        if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Coal))))
+        {
+          this.mProcessingEnergy += 160;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(3) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L));
+          }
+        }
+        else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Charcoal)))
+        {
+          this.mProcessingEnergy += 160;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(3) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L));
+          }
+        }
+        else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], "fuelCoke"))
+        {
+          this.mProcessingEnergy += 640;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(2) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L));
+          }
+        }
+        else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Lignite))))
+        {
+          this.mProcessingEnergy += 40;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(8) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L));
+          }
+        }
+      }
+      if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L))
+      {
+        this.mProcessingEnergy -= 2;
+        this.mTemperature += 1;
+      }
+      aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0);
+    }
+  }
+  
+  public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack)
+  {
+    return (aIndex == 1) || (aIndex == 3);
+  }
+  
+  public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack)
+  {
+    return aIndex == 2;
+  }
+  
+  public void doSound(byte aIndex, double aX, double aY, double aZ)
+  {
+    if (aIndex == 1)
+    {
+      GT_Utility.doSoundAtClient((String)GregTech_API.sSoundList.get(Integer.valueOf(4)), 2, 1.0F, aX, aY, aZ);
+      for (int l = 0; l < 8; l++) {
+        getBaseMetaTileEntity().getWorld().spawnParticle("largesmoke", aX - 0.5D + Math.random(), aY, aZ - 0.5D + Math.random(), 0.0D, 0.0D, 0.0D);
+      }
+    }
+  }
+  
+  public int getCapacity()
+  {
+    return 16000;
+  }
+  
+  public int getTankPressure()
+  {
+    return 100;
+  }
+}
diff --git a/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java
new file mode 100644
index 0000000000..6914e2d9d4
--- /dev/null
+++ b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaSafeBlockBase.java
@@ -0,0 +1,343 @@
+package miscutil.gregtech.api.metatileentity.implementations.base;
+
+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.metatileentity.implementations.GT_MetaTileEntity_TieredMachineBlock;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Utility;
+import miscutil.core.handler.UnbreakableBlockManager;
+import miscutil.core.util.PlayerCache;
+import miscutil.core.util.Utils;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+
+public abstract class GregtechMetaSafeBlockBase extends GT_MetaTileEntity_TieredMachineBlock {
+	public boolean bOutput = false, bRedstoneIfFull = false, bInvert = false, bUnbreakable = false;
+	public int mSuccess = 0, mTargetStackSize = 0;
+	public String ownerUUID = "";
+	UnbreakableBlockManager Xasda = new UnbreakableBlockManager();
+	private boolean value_last = false, value_current = false;
+
+	public GregtechMetaSafeBlockBase(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription) {
+		super(aID, aName, aNameRegional, aTier, aInvSlotCount, aDescription);
+	}
+
+	public GregtechMetaSafeBlockBase(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aTier, aInvSlotCount, aDescription, aTextures);
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(ITexture[] aTextures) {
+		ITexture[][][] rTextures = new ITexture[6][17][];
+		ITexture tIcon = getOverlayIcon(), tOut = new GT_RenderedTexture(Textures.BlockIcons.OVERLAY_QCHEST), tUp = new GT_RenderedTexture(Textures.BlockIcons.MACHINE_CASING_VENT), tShitGoesWrong = new GT_RenderedTexture(Textures.BlockIcons.NAQUADAH_REACTOR_FLUID_SIDE_ACTIVE);
+		for (byte i = -1; i < 16; i++) {
+			rTextures[0][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tUp, tIcon}; //Back
+			rTextures[1][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tIcon}; // Right, Strangely The top side as well when facing East?
+			rTextures[2][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tIcon}; // Top  And Bottom, When Facing South (What the hell?)
+			rTextures[3][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tIcon}; // Left, Top if facing West and Bottom if facing east?
+			rTextures[4][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tIcon}; // Top and Bottom when Facing North..
+			rTextures[5][i + 1] = new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[mTier][i + 1], tOut}; // Front
+		}
+		return rTextures;
+
+	}
+
+	@Override
+	public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+		if (aSide == aFacing) return mTextures[5][aColorIndex + 1];
+		if (GT_Utility.getOppositeSide(aSide) == aFacing) return mTextures[0][aColorIndex + 1];
+		switch (aFacing) {
+		case 0:
+			return mTextures[4][aColorIndex + 1];
+		case 1:
+			return mTextures[2][aColorIndex + 1];
+		case 2:
+			switch (aSide) {
+			case 0:
+				return mTextures[2][aColorIndex + 1];
+			case 1:
+				return mTextures[2][aColorIndex + 1];
+			case 4:
+				return mTextures[1][aColorIndex + 1];
+			case 5:
+				return mTextures[3][aColorIndex + 1];
+			}
+		case 3:
+			switch (aSide) {
+			case 0:
+				return mTextures[4][aColorIndex + 1];
+			case 1:
+				return mTextures[4][aColorIndex + 1];
+			case 4:
+				return mTextures[3][aColorIndex + 1];
+			case 5:
+				return mTextures[1][aColorIndex + 1];
+			}
+		case 4:
+			switch (aSide) {
+			case 0:
+				return mTextures[3][aColorIndex + 1];
+			case 1:
+				return mTextures[1][aColorIndex + 1];
+			case 2:
+				return mTextures[3][aColorIndex + 1];
+			case 3:
+				return mTextures[1][aColorIndex + 1];
+			}
+		case 5:
+			switch (aSide) {
+			case 0:
+				return mTextures[1][aColorIndex + 1];
+			case 1:
+				return mTextures[3][aColorIndex + 1];
+			case 2:
+				return mTextures[1][aColorIndex + 1];
+			case 3:
+				return mTextures[3][aColorIndex + 1];
+			}
+		}
+		return mTextures[5][aColorIndex + 1];
+	}
+
+	@Override
+	public boolean isSimpleMachine() {
+		return false;
+	}
+
+	@Override
+	public boolean isValidSlot(int aIndex) {
+		return aIndex < mInventory.length - 1;
+	}
+
+	@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 !isOutputFacing(aSide);
+	}
+
+	@Override
+	public boolean isOutputFacing(byte aSide) {
+		return getBaseMetaTileEntity().getBackFacing() == aSide;
+	}
+
+	@Override
+	public boolean isTeleporterCompatible() {
+		return false;
+	}
+
+	@Override
+	public long getMinimumStoredEU() {
+		return 512;
+	}
+
+	@Override
+	public long maxEUStore() {
+		return 512 + V[mTier] * 50;
+	}
+
+	@Override
+	public long maxEUInput() {
+		return V[mTier];
+	}
+
+	@Override
+	public long maxEUOutput() {
+		return bOutput ? V[mTier] : 0;
+	}
+
+	@Override
+	public long maxAmperesIn() {
+		return 1;
+	}
+
+	@Override
+	public long maxAmperesOut() {
+		return 1;
+	}
+
+	@Override
+	public boolean isAccessAllowed(EntityPlayer aPlayer) {
+		return true;
+	}
+
+	public abstract ITexture getOverlayIcon();
+
+	@Override
+	public boolean onRightclick(IGregTechTileEntity aBaseMetaTileEntity, EntityPlayer aPlayer) {
+
+		if (aBaseMetaTileEntity.isClientSide()) {			
+			//Utils.LOG_WARNING("Clicky Clicky.");			
+			return true;
+
+		}
+		if (!aPlayer.equals(null)) {
+			String tempUUID = aPlayer.getUniqueID().toString();
+			PlayerCache.appendParamChanges(aPlayer.getDisplayName(), aPlayer.getUniqueID().toString());
+			if (ownerUUID.equals("")){
+				Utils.LOG_WARNING("No owner yet for this block.");
+			}
+			else {
+				Utils.LOG_WARNING("Current Owner: "+PlayerCache.lookupPlayerByUUID(ownerUUID)+" - UUID: "+ownerUUID);
+			}
+			Utils.LOG_WARNING("Is ownerUUID Null");
+			if (ownerUUID.equals("")){
+				Utils.LOG_WARNING("OwnerUUID is Null, let's set it.");
+				Utils.LOG_WARNING("Accessing Players UUID is: "+tempUUID);
+				ownerUUID = tempUUID;
+				//Utils.messagePlayer(aPlayer, "Owner of this safe, now set. Try accessing it again.");
+				Utils.LOG_WARNING("Block Owner is now set to: "+ownerUUID);
+			}
+			Utils.LOG_WARNING("No, it is not.");
+			Utils.LOG_WARNING("Checking ownerUUID.");
+			if (!ownerUUID.equals(null)){
+				Utils.LOG_WARNING("ownerUUID != Null, if accessor == owner.");
+				Utils.LOG_WARNING("Accessing is: "+PlayerCache.lookupPlayerByUUID(tempUUID));
+				if (ownerUUID.equals(tempUUID)){
+					Utils.LOG_WARNING("Owner's UUID: "+ownerUUID);
+					aBaseMetaTileEntity.openGUI(aPlayer);
+					//Utils.LOG_WARNING("GUI should now be open for you sir.");
+				}
+				else {
+					Utils.messagePlayer(aPlayer, "Access Denied, This does not belong to you.");
+					Utils.messagePlayer(aPlayer, "it is owned by: "+PlayerCache.lookupPlayerByUUID(ownerUUID));
+					Utils.LOG_WARNING("Expecting Player : "+PlayerCache.lookupPlayerByUUID(ownerUUID));
+					Utils.LOG_ERROR("Access Denied.");
+					return true;
+				}
+
+			}
+
+			/*else {
+				Utils.LOG_ERROR("This is NOT good. Tell Draknyte1 your safe broke.");
+			}*/
+			/*Utils.LOG_WARNING("Clicky Clicky.");
+			Utils.messagePlayer(aPlayer, "Owner of this safe, now set.");
+			aBaseMetaTileEntity.openGUI(aPlayer);	*/
+
+		}
+		return true;
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		aNBT.setBoolean("bUnbreakable", bUnbreakable);
+		aNBT.setBoolean("bOutput", bOutput);
+		aNBT.setBoolean("bRedstoneIfFull", bRedstoneIfFull);
+		aNBT.setInteger("mTargetStackSize", mTargetStackSize);
+		aNBT.setString("ownerUUID", ownerUUID);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		bUnbreakable = aNBT.getBoolean("bUnbreakable");
+		bOutput = aNBT.getBoolean("bOutput");
+		bRedstoneIfFull = aNBT.getBoolean("bRedstoneIfFull");
+		mTargetStackSize = aNBT.getInteger("mTargetStackSize");
+		ownerUUID = aNBT.getString("ownerUUID");
+	}
+
+	@Override
+	public void setItemNBT(NBTTagCompound aNBT) {
+		super.setItemNBT(aNBT);
+		if (mTargetStackSize > 0) aNBT.setInteger("mTargetStackSize", mTargetStackSize);
+	}
+
+	@Override
+	public void onScrewdriverRightClick(byte aSide, EntityPlayer aPlayer, float aX, float aY, float aZ) {
+		if (aSide == getBaseMetaTileEntity().getBackFacing()) {
+			mTargetStackSize = (byte) ((mTargetStackSize + (aPlayer.isSneaking()? -1 : 1)) % 65);
+			if (mTargetStackSize == 0) {
+				GT_Utility.sendChatToPlayer(aPlayer, "Do not regulate Item Stack Size");
+			} else {
+				GT_Utility.sendChatToPlayer(aPlayer, "Regulate Item Stack Size to: " + mTargetStackSize);
+			}
+		}
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+		/*if (aBaseMetaTileEntity.isAllowedToWork() && aBaseMetaTileEntity.isServerSide() && aBaseMetaTileEntity.isUniversalEnergyStored(getMinimumStoredEU()) && (aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified() || aTimer % 200 == 0 || mSuccess > 0)) {
+		 */
+		if (aBaseMetaTileEntity.isServerSide()  && (aBaseMetaTileEntity.hasWorkJustBeenEnabled() || aBaseMetaTileEntity.hasInventoryBeenModified() || aTimer % 200 == 0 || mSuccess > 0)) {
+			value_last = value_current;
+			value_current = bUnbreakable;
+			if (value_last != value_current){
+				Utils.LOG_WARNING("VALUE CHANGE - Ticking for a moment.");
+				if (bUnbreakable == true){				
+					//Xasda.setmTileEntity((BaseMetaTileEntity) aBaseMetaTileEntity);
+					//Utils.LOG_ERROR("Safe is Indestructible.");
+					this.getBaseMetaTileEntity().getBlock(this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord(), this.getBaseMetaTileEntity().getZCoord()).setResistance(Float.MAX_VALUE);
+					this.getBaseMetaTileEntity().getBlock(this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord(), this.getBaseMetaTileEntity().getZCoord()).setBlockUnbreakable();
+				}
+				else {
+					//Xasda.setmTileEntity((BaseMetaTileEntity) aBaseMetaTileEntity);
+					//Utils.LOG_ERROR("Safe is not Indestructible.");
+					this.getBaseMetaTileEntity().getBlock(this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord(), this.getBaseMetaTileEntity().getZCoord()).setResistance(1F);
+					this.getBaseMetaTileEntity().getBlock(this.getBaseMetaTileEntity().getXCoord(), this.getBaseMetaTileEntity().getYCoord(), this.getBaseMetaTileEntity().getZCoord()).setHardness(2);
+					
+				}
+			}
+			else {
+				
+			}
+			
+
+
+
+
+
+
+
+			/*mSuccess--;
+			moveItems(aBaseMetaTileEntity, aTimer);
+			aBaseMetaTileEntity.setGenericRedstoneOutput(bInvert);
+			if (bRedstoneIfFull) {
+				aBaseMetaTileEntity.setGenericRedstoneOutput(!bInvert);
+				for (int i = 0; i < mInventory.length; i++)
+					if (isValidSlot(i)) {
+						if (mInventory[i] == null) {
+							aBaseMetaTileEntity.setGenericRedstoneOutput(bInvert);
+							aBaseMetaTileEntity.decreaseStoredEnergyUnits(1, true);
+							break;
+						}
+					}
+			}
+		}*/
+		}
+	}
+
+	/*protected void moveItems(IGregTechTileEntity aBaseMetaTileEntity, long aTimer) {
+		int tCost = GT_Utility.moveOneItemStack(aBaseMetaTileEntity, aBaseMetaTileEntity.getTileEntityAtSide(aBaseMetaTileEntity.getBackFacing()), aBaseMetaTileEntity.getBackFacing(), aBaseMetaTileEntity.getFrontFacing(), null, false, mTargetStackSize == 0 ? 64 : (byte) mTargetStackSize, mTargetStackSize == 0 ? 1 : (byte) mTargetStackSize, (byte) 64, (byte) 1);
+		if (tCost > 0 || aBaseMetaTileEntity.hasInventoryBeenModified()) {
+			mSuccess = 50;
+			aBaseMetaTileEntity.decreaseStoredEnergyUnits(Math.abs(tCost), true);
+		}
+	}*/
+
+	@Override
+	public boolean allowPullStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return true;
+	}
+
+	@Override
+	public boolean allowPutStack(IGregTechTileEntity aBaseMetaTileEntity, int aIndex, byte aSide, ItemStack aStack) {
+		return aSide != aBaseMetaTileEntity.getBackFacing();
+	}
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java
new file mode 100644
index 0000000000..de9a98c644
--- /dev/null
+++ b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechMetaTileEntity.java
@@ -0,0 +1,67 @@
+package miscutil.gregtech.api.metatileentity.implementations.base;
+
+import static gregtech.api.enums.GT_Values.GT;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.metatileentity.MetaTileEntity;
+import net.minecraft.util.EnumChatFormatting;
+
+public abstract class GregtechMetaTileEntity extends MetaTileEntity {
+	/**
+	 * Value between [0 - 9] to describe the Tier of this Machine.
+	 */
+	public final byte mTier;
+	
+	/**
+	 * A simple Description.
+	 */
+	public final String mDescription;
+	
+	/**
+	 * Contains all Textures used by this Block.
+	 */
+	public final ITexture[][][] mTextures;
+	
+	public GregtechMetaTileEntity(int aID, String aName, String aNameRegional, int aTier, int aInvSlotCount, String aDescription, ITexture... aTextures) {
+		super(aID, aName, aNameRegional, aInvSlotCount);
+		mTier = (byte)Math.max(0, Math.min(aTier, 9));
+		mDescription = aDescription;
+		
+		// must always be the last call!
+		if (GT.isClientSide()) mTextures = getTextureSet(aTextures); else mTextures = null;
+	}
+	
+	public GregtechMetaTileEntity(String aName, int aTier, int aInvSlotCount, String aDescription, ITexture[][][] aTextures) {
+		super(aName, aInvSlotCount);
+		mTier = (byte)aTier;
+		mDescription = aDescription;
+		mTextures = aTextures;
+		
+	}
+	
+	@Override
+	public byte getTileEntityBaseType() {
+		return (byte)(Math.min(3, mTier<=0?0:1+((mTier-1) / 4)));
+	}
+	
+    @Override
+	public long getInputTier() {
+    	return mTier;
+    }
+    
+    @Override
+	public long getOutputTier() {
+    	return mTier;
+    }
+    
+	@Override
+	public String[] getDescription() {
+		return new String[] {mDescription, "Added by: "	+ EnumChatFormatting.DARK_GREEN+"Alkalus"};
+	}
+	
+	/**
+	 * Used Client Side to get a Texture Set for this Block.
+	 * Called after setting the Tier and the Description so that those two are accessible.
+	 * @param aTextures is the optional Array you can give to the Constructor.
+	 */
+	public abstract ITexture[][][] getTextureSet(ITexture[] aTextures);
+}
\ No newline at end of file
diff --git a/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java
new file mode 100644
index 0000000000..0a6920c794
--- /dev/null
+++ b/src/Java/miscutil/gregtech/api/metatileentity/implementations/base/GregtechSteelBoiler.java
@@ -0,0 +1,290 @@
+package miscutil.gregtech.api.metatileentity.implementations.base;
+
+import gregtech.api.enums.Dyes;
+import gregtech.api.enums.Materials;
+import gregtech.api.enums.OrePrefixes;
+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 gregtech.api.util.GT_OreDictUnificator;
+import gregtech.common.gui.GT_Container_Boiler;
+import gregtech.common.gui.GT_GUIContainer_Boiler;
+import gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public class GregtechSteelBoiler
+  extends GT_MetaTileEntity_Boiler
+{
+  public GregtechSteelBoiler(int aID, String aName, String aNameRegional, int aTier, String aDescription)
+  {
+    super(aID, aName, aNameRegional, "Put it to good use!", new ITexture[0]);
+  }
+  
+  public GregtechSteelBoiler(String aName, int aTier, String aDescription, ITexture[][][] aTextures)
+  {
+    super(aName, aTier, aDescription, aTextures);
+  }
+  
+  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.STEAM_TURBINE_SIDE)};
+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;
+  }
+  
+  public int maxProgresstime()
+  {
+    return 1000;
+  }
+  
+  public Object getServerGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity)
+  {
+    return new GT_Container_Boiler(aPlayerInventory, aBaseMetaTileEntity, 32000);
+  }
+  
+  public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity)
+  {
+    return new GT_GUIContainer_Boiler(aPlayerInventory, aBaseMetaTileEntity, "SteelBoiler.png", 32000);
+  }
+  
+  public MetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity)
+  {
+    return new GregtechSteelBoiler(this.mName, this.mTier, this.mDescription, this.mTextures);
+  }
+  
+  public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick)
+  {
+    if ((aBaseMetaTileEntity.isServerSide()) && (aTick > 20L))
+    {
+      if (this.mTemperature <= 20)
+      {
+        this.mTemperature = 20;
+        this.mLossTimer = 0;
+      }
+      if (++this.mLossTimer > 40)
+      {
+        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 > 100)
+        {
+          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(150L);
+            } else if (GT_ModHandler.isSteam(this.mSteam)) {
+              this.mSteam.amount += 150;
+            } else {
+              this.mSteam = GT_ModHandler.getSteam(150L);
+            }
+          }
+        }
+        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()) && 
+        (this.mInventory[2] != null)) {
+        if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Coal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Coal))))
+        {
+          this.mProcessingEnergy += 160;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(3) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L));
+          }
+        }
+        else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Charcoal))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Charcoal))))
+        {
+          this.mProcessingEnergy += 160;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(3) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L));
+          }
+        }
+        else if (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], "fuelCoke"))
+        {
+          this.mProcessingEnergy += 640;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(2) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.Ash, 1L));
+          }
+        }
+        else if ((GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.gem.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dust.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.dustImpure.get(Materials.Lignite))) || (GT_OreDictUnificator.isItemStackInstanceOf(this.mInventory[2], OrePrefixes.crushed.get(Materials.Lignite))))
+        {
+          this.mProcessingEnergy += 40;
+          aBaseMetaTileEntity.decrStackSize(2, 1);
+          if (aBaseMetaTileEntity.getRandomNumber(8) == 0) {
+            aBaseMetaTileEntity.addStackToSlot(3, GT_OreDictUnificator.get(OrePrefixes.dustTiny, Materials.DarkAsh, 1L));
+          }
+        }
+      }
+      if ((this.mTemperature < 1000) && (this.mProcessingEnergy > 0) && (aTick % 12L == 0L))
+      {
+        this.mProcessingEnergy -= 2;
+        this.mTemperature += 1;
+      }
+      aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0);
+    }
+  }
+
+@Override
+public int[] getAccessibleSlotsFromSide(int p_94128_1_) {
+	// TODO Auto-generated method stub
+	return null;
+}
+
+@Override
+public boolean canInsertItem(int p_102007_1_, ItemStack p_102007_2_,
+		int p_102007_3_) {
+	// TODO Auto-generated method stub
+	return false;
+}
+
+@Override
+public boolean canExtractItem(int p_102008_1_, ItemStack p_102008_2_,
+		int p_102008_3_) {
+	// TODO Auto-generated method stub
+	return false;
+}
+
+@Override
+public int getSizeInventory() {
+	// TODO Auto-generated method stub
+	return 0;
+}
+
+@Override
+public ItemStack getStackInSlot(int p_70301_1_) {
+	// TODO Auto-generated method stub
+	return null;
+}
+
+@Override
+public ItemStack decrStackSize(int p_70298_1_, int p_70298_2_) {
+	// TODO Auto-generated method stub
+	return null;
+}
+
+@Override
+public ItemStack getStackInSlotOnClosing(int p_70304_1_) {
+	// TODO Auto-generated method stub
+	return null;
+}
+
+@Override
+public void setInventorySlotContents(int p_70299_1_, ItemStack p_70299_2_) {
+	// TODO Auto-generated method stub
+	
+}
+
+@Override
+public String getInventoryName() {
+	// TODO Auto-generated method stub
+	return null;
+}
+
+@Override
+public boolean hasCustomInventoryName() {
+	// TODO Auto-generated method stub
+	return false;
+}
+
+@Override
+public int getInventoryStackLimit() {
+	// TODO Auto-generated method stub
+	return 0;
+}
+
+@Override
+public void markDirty() {
+	// TODO Auto-generated method stub
+	
+}
+
+@Override
+public boolean isUseableByPlayer(EntityPlayer p_70300_1_) {
+	// TODO Auto-generated method stub
+	return false;
+}
+
+@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_) {
+	// TODO Auto-generated method stub
+	return false;
+}
+}
+
+
+
+/* Location:           F:\Torrent\minecraft\jd-gui-0.3.6.windows\gregtech_1.7.10-5.07.07-dev.jar
+
+ * Qualified Name:     gregtech.common.tileentities.boilers.GT_MetaTileEntity_Boiler_Steel
+
+ * JD-Core Version:    0.7.0.1
+
+ */
\ No newline at end of file