Merged in AlkWork (pull request #4)

AlkWork

12 files changed, 1736 insertions, 269 deletions

diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialPlatePress.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialPlatePress.java
index 0939a9e6be..360939eb41 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialPlatePress.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialPlatePress.java
@@ -72,9 +72,9 @@ public class GregtechMetaTileEntity_IndustrialPlatePress extends GregtechMeta_Mu
 	@Override
 	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing, final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
 		if (aSide == aFacing) {
-			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[TAE.GTPP_INDEX(4)], new GT_RenderedTexture(aActive ? TexturesGtBlock.Overlay_Machine_Controller_Default_Active : TexturesGtBlock.Overlay_Machine_Controller_Default)};
+			return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[50], new GT_RenderedTexture(aActive ? TexturesGtBlock.Overlay_Machine_Controller_Default_Active : TexturesGtBlock.Overlay_Machine_Controller_Default)};
 		}
-		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[TAE.GTPP_INDEX(4)]};
+		return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[50]};
 	}
 
 	@Override
@@ -148,7 +148,7 @@ public class GregtechMetaTileEntity_IndustrialPlatePress extends GregtechMeta_Mu
 							Block aBlock = aBaseMetaTileEntity.getBlockOffset(xDir + i, h, zDir + j);
 							int aMeta = aBaseMetaTileEntity.getMetaIDOffset(xDir + i, h, zDir + j);
 
-							if (!isValidBlockForStructure(tTileEntity, 4, true, aBlock, aMeta,
+							if (!isValidBlockForStructure(tTileEntity, 50, true, aBlock, aMeta,
 									ModBlocks.blockCasingsMisc, 4)) {
 								Logger.INFO("Bad material press casing");
 								return false;
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialWashPlant.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialWashPlant.java
index ca6eeda207..40d12356d8 100644
--- a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialWashPlant.java
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IndustrialWashPlant.java
@@ -238,7 +238,7 @@ extends GregtechMeta_MultiBlockBase {
 
 
 	public byte getCasingTextureIndex() {
-		return (byte) TAE.GTPP_INDEX(20);
+		return (byte) TAE.GTPP_INDEX(11);
 	}
 
 	private boolean addToMachineList(final IGregTechTileEntity tTileEntity) {
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IsaMill.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IsaMill.java
new file mode 100644
index 0000000000..d06b7ed0d1
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/GregtechMetaTileEntity_IsaMill.java
@@ -0,0 +1,404 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing;
+
+import java.util.HashSet;
+import java.util.List;
+
+import gregtech.api.enums.TAE;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.Recipe_GT;
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.EntityUtils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock.CustomIcon;
+import net.minecraft.block.Block;
+import net.minecraft.entity.EntityLivingBase;
+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.util.DamageSource;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+
+public class GregtechMetaTileEntity_IsaMill extends GregtechMeta_MultiBlockBase {
+
+	protected int fuelConsumption = 0;
+	protected int fuelValue = 0;
+	protected int fuelRemaining = 0;
+	protected boolean boostEu = false;
+
+	private static ITexture frontFace;
+	private static ITexture frontFaceActive;
+	
+	private static final DamageSource mIsaMillDamageSource = new DamageSource("gtpp.grinder").setDamageBypassesArmor();
+
+	public GregtechMetaTileEntity_IsaMill(int aID, String aName, String aNameRegional) {
+		super(aID, aName, aNameRegional);
+		frontFaceActive = new GT_RenderedTexture(new CustomIcon("iconsets/Grinder/GRINDER_ACTIVE5"));
+		frontFace = new GT_RenderedTexture(new CustomIcon("iconsets/Grinder/GRINDER5"));
+	}
+
+	public GregtechMetaTileEntity_IsaMill(String aName) {
+		super(aName);
+	}
+
+	public String[] getTooltip() {
+		return new String[]{
+				"Controller Block for the Large Grinding Machine",
+				"Engine Intake Casings must not be obstructed in front (only air blocks)",
+				"Supply Semifluid Fuels and 2000L of Lubricant per hour to run.",
+				"Supply 80L of Oxygen per second to boost output (optional).",
+				"Default: Produces 2048EU/t at 100% efficiency",
+				"Boosted: Produces 6144EU/t at 150% efficiency",
+				"Size(WxHxD): 3x3x4, Controller (front centered)",
+				"3x3x4 of Stable Titanium Machine Casing (hollow, Min 16!)",
+				"All hatches except dynamo can replace any Stable Titanium casing in middle two segments",
+				"2x Steel Gear Box Machine Casing inside the Hollow Casing",
+				"8x Engine Intake Machine Casing (around controller)",
+				"2x Input Hatch (Fuel/Lubricant)",
+				"1x Maintenance Hatch",
+				"1x Muffler Hatch",
+				"1x Dynamo Hatch (back centered)",
+		};
+	}
+
+
+	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing, final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
+		return new ITexture[]{
+				Textures.BlockIcons.CASING_BLOCKS[TAE.GTPP_INDEX(2)],
+				aFacing == aSide ? aActive ? frontFaceActive : frontFace : Textures.BlockIcons.CASING_BLOCKS[TAE.GTPP_INDEX(2)]};
+	}
+
+	@Override
+	public boolean isCorrectMachinePart(ItemStack aStack) {
+		return getMaxEfficiency(aStack) > 0;
+	}
+
+	public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+		return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "LargeDieselEngine.png");
+	}
+
+	@Override
+	public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+		return Recipe_GT.Gregtech_Recipe_Map.sOreMillRecipes;
+	}
+
+	@Override
+	public void onPostTick(IGregTechTileEntity aBaseMetaTileEntity, long aTick) {
+		super.onPostTick(aBaseMetaTileEntity, aTick);
+		if (aTick % 20 == 0) {
+			checkForEntities(aBaseMetaTileEntity, aTick);			
+		}
+	}
+
+	private final AutoMap<BlockPos> mFrontBlockPosCache = new AutoMap<BlockPos>();
+
+	public void checkForEntities(IGregTechTileEntity aBaseMetaTileEntity, long aTime) {
+
+		if (aTime % 100 == 0) {
+			mFrontBlockPosCache.clear();
+		}
+		if (mFrontBlockPosCache.isEmpty()) {
+			byte tSide = aBaseMetaTileEntity.getBackFacing();
+			int aTileX = aBaseMetaTileEntity.getXCoord();
+			int aTileY = aBaseMetaTileEntity.getYCoord();
+			int aTileZ = aBaseMetaTileEntity.getZCoord();
+			boolean xFacing = (tSide == 4 || tSide == 5);
+			boolean zFacing = (tSide == 2 || tSide == 3);
+
+			// Check Casings
+			int aDepthOffset = (tSide == 2 || tSide == 4) ? 1 : -1;
+			for (int aHorizontalOffset = -1; aHorizontalOffset < 2; aHorizontalOffset++) {
+				for (int aVerticalOffset = -1; aVerticalOffset < 2; aVerticalOffset++) {			
+					int aX = !xFacing ? (aTileX + aHorizontalOffset) : (aTileX + aDepthOffset);
+					int aY = aTileY + aVerticalOffset;
+					int aZ = !zFacing ? (aTileZ + aHorizontalOffset) : (aTileZ + aDepthOffset);					
+					mFrontBlockPosCache.add(new BlockPos(aX, aY, aZ, aBaseMetaTileEntity.getWorld()));
+				}
+			}
+		}
+
+		AutoMap<EntityLivingBase> aEntities = getEntities(mFrontBlockPosCache, aBaseMetaTileEntity.getWorld());
+		if (!aEntities.isEmpty()) {
+			for (EntityLivingBase aFoundEntity : aEntities) {
+				if (aFoundEntity instanceof EntityPlayer) {
+					EntityPlayer aPlayer = (EntityPlayer) aFoundEntity;
+					if (PlayerUtils.isCreative(aPlayer) || !PlayerUtils.canTakeDamage(aPlayer)) {
+						continue;
+					}
+					else {
+						if (aFoundEntity.getHealth() > 0) {
+							EntityUtils.doDamage(aFoundEntity, mIsaMillDamageSource, (int) (aFoundEntity.getMaxHealth() / 5));
+							if ((aBaseMetaTileEntity.isClientSide()) && (aBaseMetaTileEntity.isActive())) {
+								generateParticles(aFoundEntity);
+							}
+						}
+					}
+				}
+				if (aFoundEntity.getHealth() > 0) {
+					EntityUtils.doDamage(aFoundEntity, mIsaMillDamageSource, Math.max(1, (int) (aFoundEntity.getMaxHealth() / 3)));
+					if ((aBaseMetaTileEntity.isClientSide()) && (aBaseMetaTileEntity.isActive())) {
+						generateParticles(aFoundEntity);
+					}
+				}
+			}
+		}
+	}
+
+	private static final AutoMap<EntityLivingBase> getEntities(AutoMap<BlockPos> aPositionsToCheck, World aWorld){
+		AutoMap<EntityLivingBase> aEntities = new AutoMap<EntityLivingBase>();
+		HashSet<Chunk> aChunksToCheck = new HashSet<Chunk>();
+		if (!aPositionsToCheck.isEmpty()) {
+			Chunk aLocalChunk;
+			for (BlockPos aPos : aPositionsToCheck) {
+				aLocalChunk = aWorld.getChunkFromBlockCoords(aPos.xPos, aPos.zPos);
+				aChunksToCheck.add(aLocalChunk);				
+			}
+		}
+		if (!aChunksToCheck.isEmpty()) {	
+			AutoMap<EntityLivingBase> aEntitiesFound = new AutoMap<EntityLivingBase>();
+			for (Chunk aChunk : aChunksToCheck) {				
+				if (aChunk.isChunkLoaded) {
+					List[] aEntityLists = aChunk.entityLists;
+					for (List aEntitySubList : aEntityLists) {
+						for (Object aEntity : aEntitySubList) {
+							if (aEntity instanceof EntityLivingBase) {
+								EntityLivingBase aPlayer = (EntityLivingBase) aEntity;
+								aEntitiesFound.add(aPlayer);
+							}
+						}
+					}
+				}				
+			}
+			if (!aEntitiesFound.isEmpty()) {
+				for (EntityLivingBase aEntity : aEntitiesFound) {
+					BlockPos aPlayerPos = EntityUtils.findBlockPosOfEntity(aEntity);
+					for (BlockPos aBlockSpaceToCheck : aPositionsToCheck) {
+						if (aBlockSpaceToCheck.equals(aPlayerPos)) {
+							aEntities.add(aEntity);
+						}
+					}
+				}
+			}
+		}		
+		return aEntities;
+	}
+
+	private static void generateParticles(EntityLivingBase aEntity) {
+		BlockPos aPlayerPosBottom = EntityUtils.findBlockPosOfEntity(aEntity);
+		BlockPos aPlayerPosTop = aPlayerPosBottom.getUp();
+		AutoMap<BlockPos> aEntityPositions = new AutoMap<BlockPos>();
+		aEntityPositions.add(aPlayerPosBottom);
+		aEntityPositions.add(aPlayerPosTop);
+		for (int i = 0; i < 64; i++) {	
+			BlockPos aEffectPos = aEntityPositions.get(aEntity.height > 1f ? MathUtils.randInt(0, 1) : 0);
+			float aOffsetX = MathUtils.randFloat(-0.35f, 0.35f);
+			float aOffsetY = MathUtils.randFloat(-0.25f, 0.35f);
+			float aOffsetZ = MathUtils.randFloat(-0.35f, 0.35f);
+			aEntity.worldObj.spawnParticle("reddust", aEffectPos.xPos + aOffsetX, aEffectPos.yPos + 0.3f + aOffsetY, aEffectPos.zPos + aOffsetZ, 0.0D, 0.0D, 0.0D);
+		}
+	}
+
+	@Override
+	public boolean isFacingValid(final byte aFacing) {
+		return aFacing > 1;
+	}
+
+	@Override
+	public boolean checkRecipe(ItemStack aStack) {
+		return checkRecipeGeneric();
+	}
+
+	@Override
+	public boolean checkMultiblock(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		byte tSide = aBaseMetaTileEntity.getBackFacing();
+		int aTileX = aBaseMetaTileEntity.getXCoord();
+		int aTileY = aBaseMetaTileEntity.getYCoord();
+		int aTileZ = aBaseMetaTileEntity.getZCoord();
+		boolean xFacing = (tSide == 4 || tSide == 5);
+		boolean zFacing = (tSide == 2 || tSide == 3);
+		int aCasingCount = 0;
+		// Check Intake Hatches
+		for (int aHorizontalOffset = -1; aHorizontalOffset < 2; aHorizontalOffset++) {
+			for (int aVerticalOffset = -1; aVerticalOffset < 2; aVerticalOffset++) {
+				if (aHorizontalOffset == 0 && aVerticalOffset == 0) {
+					continue;
+				}			
+				int aX = !xFacing ? (aTileX + aHorizontalOffset) : aTileX;
+				int aY = aTileY + aVerticalOffset;
+				int aZ = !zFacing ? (aTileZ + aHorizontalOffset) : aTileZ;
+				Block aIntakeBlock = aBaseMetaTileEntity.getBlock(aX, aY, aZ);
+				int aIntakeMeta = aBaseMetaTileEntity.getMetaID(aX, aY, aZ);				
+				if (!isValidBlockForStructure(null, 0, false, aIntakeBlock, aIntakeMeta, getIntakeBlock(), getIntakeMeta())) {
+					return false; // Not intake casing surrounding controller					
+				}
+			}
+		}
+		// Check Casings
+		int aStartDepthOffset = (tSide == 2 || tSide == 4) ? -1 : 1;
+		int aFinishDepthOffset = (tSide == 2 || tSide == 4) ? -8 : 8;
+		for (int aDepthOffset = aStartDepthOffset; aDepthOffset != aFinishDepthOffset;) {
+			for (int aHorizontalOffset = -1; aHorizontalOffset < 2; aHorizontalOffset++) {
+				for (int aVerticalOffset = -1; aVerticalOffset < 2; aVerticalOffset++) {
+					if (aHorizontalOffset == 0 && aVerticalOffset == 0) {
+						continue;
+					}				
+					int aX = !xFacing ? (aTileX + aHorizontalOffset) : (aTileX + aDepthOffset);
+					int aY = aTileY + aVerticalOffset;
+					int aZ = !zFacing ? (aTileZ + aHorizontalOffset) : (aTileZ + aDepthOffset);
+					Block aCasingBlock = aBaseMetaTileEntity.getBlock(aX, aY, aZ);
+					int aCasingMeta = aBaseMetaTileEntity.getMetaID(aX, aY, aZ);	
+					IGregTechTileEntity aTileEntity = aBaseMetaTileEntity.getIGregTechTileEntity(aX, aY, aZ);
+					if (aTileEntity != null) {
+						final IMetaTileEntity aMetaTileEntity = aTileEntity.getMetaTileEntity();
+						if (aMetaTileEntity != null) {
+							if (aMetaTileEntity instanceof GregtechMetaTileEntity_IsaMill) {
+								Logger.INFO("Don't be cheeky, only one controller per Mill.");
+								return false;
+							}
+						}
+					}
+
+					if (!isValidBlockForStructure(aTileEntity, getCasingTextureIndex(), true, aCasingBlock, aCasingMeta, getCasingBlock(), getCasingMeta())) {
+						Logger.INFO("Bad casing.");
+						return false; // Not valid casing					
+					}
+					else {
+						if (aTileEntity == null) {
+							aCasingCount++;
+						}
+					}
+				}
+			}
+			// Count Backwards for 2 axis
+			if (aStartDepthOffset == -1) {
+				aDepthOffset--;
+			}
+			// Count Forwards for 2 axis
+			else {
+				aDepthOffset++;
+			}
+		}
+
+		// Check Gear Boxes
+		for (int aInternalDepthAxis = 1; aInternalDepthAxis < 7; aInternalDepthAxis++) {
+			if(aBaseMetaTileEntity.getBlockAtSideAndDistance(tSide, aInternalDepthAxis) != getGearboxBlock() || aBaseMetaTileEntity.getMetaIDAtSideAndDistance(tSide, aInternalDepthAxis) != getGearboxMeta()) {
+				Logger.INFO("Missing Gearbox at depth "+aInternalDepthAxis);
+				return false;
+			}
+		}
+		return aCasingCount >= 48;
+	}
+
+	public Block getCasingBlock() {
+		return ModBlocks.blockCasings5Misc;
+	}
+
+	public byte getCasingMeta() {
+		return 0;
+	}
+
+	public Block getIntakeBlock() {
+		return ModBlocks.blockCasings5Misc;
+	}
+
+	public byte getIntakeMeta() {
+		return 0;
+	}
+
+	public Block getGearboxBlock() {
+		return ModBlocks.blockCasings5Misc;
+	}
+
+	public byte getGearboxMeta() {
+		return 2;
+	}
+
+	public byte getCasingTextureIndex() {
+		return 66;
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaTileEntity_IsaMill(this.mName);
+	}
+
+	@Override
+	public void saveNBTData(NBTTagCompound aNBT) {
+		super.saveNBTData(aNBT);
+	}
+
+	@Override
+	public void loadNBTData(NBTTagCompound aNBT) {
+		super.loadNBTData(aNBT);
+	}
+
+	@Override
+	public int getDamageToComponent(ItemStack aStack) {
+		return 1;
+	}
+
+	public int getMaxEfficiency(ItemStack aStack) {
+		return boostEu ? 20000 : 10000;
+	}
+
+	@Override
+	public int getPollutionPerTick(ItemStack aStack) {
+		return 64;
+	}
+
+	@Override
+	public boolean explodesOnComponentBreak(ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public String[] getExtraInfoData() {
+		return new String[]{
+				"IsaMill Grinding Machine",
+				"Current Efficiency: " + (mEfficiency / 100) + "%",
+				getIdealStatus() == getRepairStatus() ? "No Maintainance issues" : "Needs Maintainance"
+		};
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public boolean hasSlotInGUI() {
+		return false;
+	}
+
+	@Override
+	public String getCustomGUIResourceName() {
+		return null;
+	}
+
+	@Override
+	public String getMachineType() {
+		return "Grinding Machine";
+	}
+
+	@Override
+	public int getMaxParallelRecipes() {
+		return 1;
+	}
+
+	@Override
+	public int getEuDiscountForParallelism() {
+		return 0;
+	}
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_AssemblyLine.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_AssemblyLine.java
new file mode 100644
index 0000000000..eab997adb4
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/multi/processing/advanced/GregtechMetaTileEntity_Adv_AssemblyLine.java
@@ -0,0 +1,623 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.multi.processing.advanced;
+
+import java.util.ArrayList;
+import gregtech.api.GregTech_API;
+import gregtech.api.enums.GT_Values;
+import gregtech.api.enums.ItemList;
+import gregtech.api.enums.TAE;
+import gregtech.api.enums.Textures;
+import gregtech.api.gui.GT_GUIContainer_MultiMachine;
+import gregtech.api.interfaces.ITexture;
+import gregtech.api.interfaces.metatileentity.IMetaTileEntity;
+import gregtech.api.interfaces.tileentity.IGregTechTileEntity;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch;
+import gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_DataAccess;
+import gregtech.api.objects.GT_RenderedTexture;
+import gregtech.api.util.GT_Recipe;
+import gregtech.api.util.GT_Utility;
+import gtPlusPlus.core.block.ModBlocks;
+import gtPlusPlus.core.util.minecraft.LangUtils;
+import gtPlusPlus.core.util.minecraft.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.GT_MetaTileEntity_Hatch_Naquadah;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMeta_MultiBlockBase;
+import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.FluidStack;
+
+public class GregtechMetaTileEntity_Adv_AssemblyLine
+        extends GregtechMeta_MultiBlockBase {
+
+    public ArrayList<GT_MetaTileEntity_Hatch_DataAccess> mDataAccessHatches = new ArrayList<GT_MetaTileEntity_Hatch_DataAccess>();
+	
+    public static String[] mCasingName = new String[5];
+	private final int CASING_TEXTURE_ID = TAE.getIndexFromPage(0, 13);
+	private final int META_BaseCasing = 0; //4
+	private final int META_ContainmentCasing = 15; //3
+	private final int META_Shielding = 13; //1
+	private final int META_PipeCasing = 1; //4
+	private final int META_IntegralCasing = 6; //0
+	private final int META_ContainmentChamberCasing = 2; //4
+	
+	
+    public GregtechMetaTileEntity_Adv_AssemblyLine(int aID, String aName, String aNameRegional) {
+        super(aID, aName, aNameRegional);
+		mCasingName[0] = LangUtils.getLocalizedNameOfBlock(getCasing(4), 0);
+		mCasingName[1] = LangUtils.getLocalizedNameOfBlock(getCasing(4), 1);
+		mCasingName[2] = LangUtils.getLocalizedNameOfBlock(getCasing(4), 2);
+		mCasingName[3] = LangUtils.getLocalizedNameOfBlock(getCasing(3), 15);
+		mCasingName[4] = LangUtils.getLocalizedNameOfBlock(getCasing(1), 13);	
+    }
+
+    public GregtechMetaTileEntity_Adv_AssemblyLine(String aName) {
+        super(aName);
+    }
+
+    public IMetaTileEntity newMetaEntity(IGregTechTileEntity aTileEntity) {
+        return new GregtechMetaTileEntity_Adv_AssemblyLine(this.mName);
+    }
+
+    public String[] getTooltip() {
+		if (mCasingName[0].toLowerCase().contains(".name")) {
+			mCasingName[0] = LangUtils.getLocalizedNameOfBlock(getCasing(4), 0);
+		}
+		if (mCasingName[1].toLowerCase().contains(".name")) {
+			mCasingName[1] = LangUtils.getLocalizedNameOfBlock(getCasing(4), 1);
+		}
+		if (mCasingName[2].toLowerCase().contains(".name")) {
+			mCasingName[2] = LangUtils.getLocalizedNameOfBlock(getCasing(4), 2);
+		}
+		if (mCasingName[3].toLowerCase().contains(".name")) {
+			mCasingName[3] = LangUtils.getLocalizedNameOfBlock(getCasing(3), 15);
+		}
+		if (mCasingName[4].toLowerCase().contains(".name")) {
+			mCasingName[4] = LangUtils.getLocalizedNameOfBlock(getCasing(1), 13);
+		}
+        return new String[]{
+        		"Advanced Integrated Assembly Line"
+        };
+    }
+    
+	private Block getCasing(int casingID) {
+		if (casingID == 1) {
+			return ModBlocks.blockCasingsMisc;
+		}
+		else if (casingID == 2) {
+			return ModBlocks.blockCasings2Misc;
+		}
+		else if (casingID == 3) {
+			return ModBlocks.blockCasings3Misc;
+		}
+		else if (casingID == 4) {
+			return ModBlocks.blockCasings4Misc;
+		}
+		else {
+			return ModBlocks.blockCasingsTieredGTPP;
+		}
+	}
+
+    public ITexture[] getTexture(IGregTechTileEntity aBaseMetaTileEntity, byte aSide, byte aFacing, byte aColorIndex, boolean aActive, boolean aRedstone) {
+        if (aSide == aFacing) {
+            return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[16], new GT_RenderedTexture(aActive ? Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE_ACTIVE : Textures.BlockIcons.OVERLAY_FRONT_ASSEMBLY_LINE)};
+        }
+        return new ITexture[]{Textures.BlockIcons.CASING_BLOCKS[16]};
+    }
+
+    public Object getClientGUI(int aID, InventoryPlayer aPlayerInventory, IGregTechTileEntity aBaseMetaTileEntity) {
+        return new GT_GUIContainer_MultiMachine(aPlayerInventory, aBaseMetaTileEntity, getLocalName(), "AssemblyLine.png");
+    }
+
+    public GT_Recipe.GT_Recipe_Map getRecipeMap() {
+        return null;
+    }
+
+    public boolean isCorrectMachinePart(ItemStack aStack) {
+        return true;
+    }
+
+    public boolean isFacingValid(byte aFacing) {
+        return aFacing > 1;
+    }
+
+    public boolean checkRecipe(ItemStack aStack) {
+    	if(GT_Values.D1)System.out.println("Start ALine recipe check");
+        ArrayList<ItemStack> tDataStickList = getDataItems(2);
+    	if (tDataStickList.size() == 0) return false;
+    	if(GT_Values.D1)System.out.println("Stick accepted, " + tDataStickList.size() + " Data Sticks found");
+
+        ItemStack tStack[] = new ItemStack[15];
+    	FluidStack[] tFluids = new FluidStack[4];
+    	boolean findRecipe = false;
+    	nextDS:for (ItemStack tDataStick : tDataStickList){
+    		NBTTagCompound tTag = tDataStick.getTagCompound();
+    		if (tTag == null) continue;
+    		for (int i = 0; i < 15; i++) {
+    			int count = tTag.getInteger("a"+i);
+                if (!tTag.hasKey("" + i) && count <= 0) continue;
+                if (mInputBusses.get(i) == null) {
+                	continue nextDS;
+                }
+                
+                ItemStack stackInSlot = mInputBusses.get(i).getBaseMetaTileEntity().getStackInSlot(0);
+                boolean flag = true;
+                if (count > 0) {
+            		for (int j = 0; j < count; j++) {
+            			tStack[i] = GT_Utility.loadItem(tTag, "a" + i + ":" + j);
+            			if (tStack[i] == null) continue;
+            			if(GT_Values.D1)System.out.println("Item "+i+" : "+tStack[i].getUnlocalizedName());
+            			if (GT_Utility.areStacksEqual(tStack[i], stackInSlot, true) && tStack[i].stackSize <= stackInSlot.stackSize) {
+            				flag = false;
+            				break;
+            			}
+            		}
+            	}
+                if (flag) {
+            		tStack[i] = GT_Utility.loadItem(tTag, "" + i);
+            		if (tStack[i] == null) {
+            			flag = false;
+            			continue;
+            		}
+            		if(GT_Values.D1)System.out.println("Item "+i+" : "+tStack[i].getUnlocalizedName());
+        			if (GT_Utility.areStacksEqual(tStack[i], stackInSlot, true) && tStack[i].stackSize <= stackInSlot.stackSize) {
+        				flag = false;
+        			}
+            	}
+                if(GT_Values.D1) System.out.println(i + (flag ? " not accepted" : " accepted"));
+                if (flag) continue nextDS;
+            }
+    		
+    		if(GT_Values.D1)System.out.println("All Items done, start fluid check");
+            for (int i = 0; i < 4; i++) {
+                if (!tTag.hasKey("f" + i)) continue;
+                tFluids[i] = GT_Utility.loadFluid(tTag, "f" + i);
+                if (tFluids[i] == null) continue;
+            	if(GT_Values.D1)System.out.println("Fluid "+i+" "+tFluids[i].getUnlocalizedName());
+                if (mInputHatches.get(i) == null) {
+                	continue nextDS;
+                }
+                FluidStack fluidInHatch = mInputHatches.get(i).mFluid;
+                if (fluidInHatch == null || !GT_Utility.areFluidsEqual(fluidInHatch, tFluids[i], true) || fluidInHatch.amount < tFluids[i].amount) {
+                	if(GT_Values.D1)System.out.println(i+" not accepted");
+                	continue nextDS;
+                }
+            	if(GT_Values.D1)System.out.println(i+" accepted");
+            }
+            
+            if(GT_Values.D1)System.out.println("Input accepted, check other values");
+            if (!tTag.hasKey("output")) continue;
+            mOutputItems = new ItemStack[]{GT_Utility.loadItem(tTag, "output")};
+            if (mOutputItems[0] == null || !GT_Utility.isStackValid(mOutputItems[0]))
+                continue;
+            
+            if (!tTag.hasKey("time")) continue;
+            mMaxProgresstime = tTag.getInteger("time");
+            if (mMaxProgresstime <= 0) continue;
+            
+            if (!tTag.hasKey("eu")) continue;
+            mEUt = tTag.getInteger("eu");
+            
+            if(GT_Values.D1)System.out.println("Find avaiable recipe");
+            findRecipe = true;
+            break;
+    	}
+    	if (!findRecipe) return false;
+
+    	if(GT_Values.D1)System.out.println("All checked start consuming inputs");
+        for (int i = 0; i < 15; i++) {
+            if (tStack[i] == null) continue;
+            ItemStack stackInSlot = mInputBusses.get(i).getBaseMetaTileEntity().getStackInSlot(0);
+            stackInSlot.stackSize -= tStack[i].stackSize;
+        }
+
+        for (int i = 0; i < 4; i++) {
+            if (tFluids[i] == null) continue;
+            mInputHatches.get(i).mFluid.amount -= tFluids[i].amount;
+            if (mInputHatches.get(i).mFluid.amount <= 0) {
+                mInputHatches.get(i).mFluid = null;
+            }
+        }
+    	if(GT_Values.D1)System.out.println("Check overclock");
+
+        byte tTier = (byte) Math.max(1, GT_Utility.getTier(getMaxInputVoltage()));
+        this.mEfficiency = (10000 - (getIdealStatus() - getRepairStatus()) * 1000);
+        this.mEfficiencyIncrease = 10000;
+        if (mEUt <= 16) {
+            this.mEUt = (mEUt * (1 << tTier - 1) * (1 << tTier - 1));
+            this.mMaxProgresstime = (mMaxProgresstime / (1 << tTier - 1));
+        } else {
+            while (this.mEUt <= gregtech.api.enums.GT_Values.V[(tTier - 1)]) {
+                this.mEUt *= 4;
+                this.mMaxProgresstime /= 2;
+            }
+        }
+        if (this.mEUt > 0) {
+            this.mEUt = -this.mEUt;
+        }
+        this.mMaxProgresstime = Math.max(1, this.mMaxProgresstime);
+        updateSlots();
+    	if(GT_Values.D1)System.out.println("Recipe sucessfull");
+        return true;
+    }
+
+    public void startSoundLoop(byte aIndex, double aX, double aY, double aZ) {
+        super.startSoundLoop(aIndex, aX, aY, aZ);
+        if (aIndex == 20) {
+            GT_Utility.doSoundAtClient(GregTech_API.sSoundList.get(212), 10, 1.0F, aX, aY, aZ);
+        }
+    }
+
+	public boolean checkMultiblock(IGregTechTileEntity aBaseMetaTileEntity, ItemStack aStack) {
+		int xDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetX * 4;
+		int zDir = ForgeDirection.getOrientation(aBaseMetaTileEntity.getBackFacing()).offsetZ * 4;
+
+		// Counts for all Casing Types
+		int aBaseCasingCount = 0;
+		int aContainmentCasingCount = 0;
+		int aShieldingCount = 0;
+		int aPipeCount = 0;
+		int aIntegralCasingCount = 0;
+		int aContainmentChamberCount = 0;		
+
+		// Bottom Layer
+		aBaseCasingCount += checkEntireLayer(aBaseMetaTileEntity, getCasing(4), META_BaseCasing, -7, xDir, zDir);
+		log("Bottom Layer is Valid. Moving to Layer 1.");
+
+		// Layer 1
+		aShieldingCount += checkOuterRing(aBaseMetaTileEntity, getCasing(1), this.META_Shielding, -6, xDir, zDir);
+		aIntegralCasingCount += checkIntegralRing(aBaseMetaTileEntity, getCasing(0), this.META_IntegralCasing, -6, xDir, zDir);
+		aContainmentChamberCount += checkContainmentRing(aBaseMetaTileEntity, getCasing(4), this.META_ContainmentChamberCasing, -6, xDir, zDir);
+		log("Layer 1 is Valid. Moving to Layer 2.");
+
+		// Layer 2
+		aShieldingCount += checkOuterRing(aBaseMetaTileEntity, getCasing(1), this.META_Shielding, -5, xDir, zDir);
+		aPipeCount += checkPipes(aBaseMetaTileEntity, getCasing(4), this.META_PipeCasing, -5, xDir, zDir);
+		log("Layer 2 is Valid. Moving to Layer 3.");
+
+		// Layer 3
+		aContainmentCasingCount += checkOuterRing(aBaseMetaTileEntity, getCasing(3), this.META_ContainmentCasing, -4, xDir, zDir);
+		aPipeCount += checkPipes(aBaseMetaTileEntity, getCasing(4), this.META_PipeCasing, -4, xDir, zDir);
+		log("Layer 3 is Valid. Moving to Layer 4.");
+
+		// Layer 4
+		aContainmentCasingCount += checkOuterRing(aBaseMetaTileEntity, getCasing(3), this.META_ContainmentCasing, -3, xDir, zDir);
+		aPipeCount += checkPipes(aBaseMetaTileEntity, getCasing(4), this.META_PipeCasing, -3, xDir, zDir);
+		log("Layer 4 is Valid. Moving to Layer 5.");
+
+		// Layer 5
+		aShieldingCount += checkOuterRing(aBaseMetaTileEntity, getCasing(1), this.META_Shielding, -2, xDir, zDir);
+		aPipeCount += checkPipes(aBaseMetaTileEntity, getCasing(4), this.META_PipeCasing, -2, xDir, zDir);
+		log("Layer 5 is Valid. Moving to Layer 6.");
+
+		// Layer 6
+		aShieldingCount += checkOuterRing(aBaseMetaTileEntity, getCasing(1), this.META_Shielding, -1, xDir, zDir);
+		aIntegralCasingCount += checkIntegralRing(aBaseMetaTileEntity, getCasing(0), this.META_IntegralCasing, -1, xDir, zDir);
+		aContainmentChamberCount += checkContainmentRing(aBaseMetaTileEntity, getCasing(4), this.META_ContainmentChamberCasi