+ Added a Pollution Detector.

- Disabled some unused Gregtech Tile Entities.
% Refactored some classes to be in better locations.

2 files changed, 547 insertions, 0 deletions

diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaCondensor.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaCondensor.java
new file mode 100644
index 0000000000..fa013f49ab
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaCondensor.java
@@ -0,0 +1,172 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic;
+
+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 gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.Utils;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.xmod.gregtech.api.gui.CONTAINER_SteamCondenser;
+import gtPlusPlus.xmod.gregtech.api.gui.GUI_SteamCondenser;
+import gtPlusPlus.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(final int aID, final String aName, final String aNameRegional)
+	{
+		super(aID, aName, aNameRegional, "A Steam condenser - [IC2->Steam]", new ITexture[0]);
+	}
+
+	public GregtechMetaCondensor(final String aName, final int aTier, final String aDescription, final ITexture[][][] aTextures)
+	{
+		super(aName, aTier, aDescription, aTextures);
+	}
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {this.mDescription, CORE.GT_Tooltip};
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(final ITexture[] aTextures)
+	{
+		final 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;
+	}
+
+	@Override
+	public int maxProgresstime()
+	{
+		return 1000;
+	}
+
+	@Override
+	public Object getServerGUI(final int aID, final InventoryPlayer aPlayerInventory, final IGregTechTileEntity aBaseMetaTileEntity)
+	{
+		return new CONTAINER_SteamCondenser(aPlayerInventory, aBaseMetaTileEntity, 32000);
+	}
+
+	@Override
+	public Object getClientGUI(final int aID, final InventoryPlayer aPlayerInventory, final IGregTechTileEntity aBaseMetaTileEntity)
+	{
+		return new GUI_SteamCondenser(aPlayerInventory, aBaseMetaTileEntity, "SteelBoiler.png", 32000);
+	}
+
+	@Override
+	public MetaTileEntity newMetaEntity(final IGregTechTileEntity aTileEntity)
+	{
+		return new GregtechMetaCondensor(this.mName, this.mTier, this.mDescription, this.mTextures);
+	}
+
+	@Override
+	public void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final 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())
+				{
+					final IFluidHandler tTileEntity = aBaseMetaTileEntity.getITankContainerAtSide(i);
+					if (tTileEntity != null)
+					{
+						final FluidStack tDrained = aBaseMetaTileEntity.drain(ForgeDirection.getOrientation(i), Math.max(1, this.mSteam.amount / 2), false);
+						if (tDrained != null)
+						{
+							final 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))
+			{
+				this.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 % this.RI) == 0L))
+			{
+				this.mProcessingEnergy -= 40;
+				this.mTemperature += 2;
+			}
+			aBaseMetaTileEntity.setActive(this.mProcessingEnergy > 0);
+		}
+	}
+
+	@Override
+	public final int fill(final FluidStack aFluid, final boolean doFill)
+	{
+		if ((Utils.isIC2Steam(aFluid)) && (this.mProcessingEnergy < 50))
+		{
+			final int tFilledAmount = Math.min(50, aFluid.amount);
+			if (doFill) {
+				this.mProcessingEnergy += tFilledAmount;
+			}
+			return tFilledAmount;
+		}
+		return super.fill(aFluid, doFill);
+	}
+}
diff --git a/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionDetector.java b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionDetector.java
new file mode 100644
index 0000000000..a9f1c68bc4
--- /dev/null
+++ b/src/Java/gtPlusPlus/xmod/gregtech/common/tileentities/machines/basic/GregtechMetaPollutionDetector.java
@@ -0,0 +1,375 @@
+package gtPlusPlus.xmod.gregtech.common.tileentities.machines.basic;
+
+import static gregtech.api.enums.GT_Values.V;
+
+import gregtech.GT_Mod;
+import gregtech.api.enums.Textures;
+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_Utility;
+import gregtech.common.GT_Pollution;
+import gtPlusPlus.core.lib.CORE;
+import gtPlusPlus.core.util.player.PlayerUtils;
+import gtPlusPlus.xmod.gregtech.api.metatileentity.implementations.base.GregtechMetaTileEntity;
+import gtPlusPlus.xmod.gregtech.common.blocks.textures.TexturesGtBlock;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.world.World;
+
+public class GregtechMetaPollutionDetector extends GregtechMetaTileEntity {
+
+	int mCurrentPollution;
+	int mAveragePollution;
+	int mAveragePollutionArray[] = new int[10];
+	private int mArrayPos = 0;
+	private int mTickTimer = 0;
+	private int mSecondTimer = 0;
+
+	public GregtechMetaPollutionDetector(final int aID, final String aName, final String aNameRegional, final int aTier, final String aDescription, final int aSlotCount) {
+		super(aID, aName, aNameRegional, aTier, aSlotCount, aDescription);
+	}
+
+	public GregtechMetaPollutionDetector(final String aName, final int aTier, final String aDescription, final ITexture[][][] aTextures, final int aSlotCount) {
+		super(aName, aTier, aSlotCount, aDescription, aTextures);
+	}
+
+	@Override
+	public String[] getDescription() {
+		return new String[] {this.mDescription, CORE.GT_Tooltip};
+	}
+
+	@Override
+	public ITexture[][][] getTextureSet(final ITexture[] aTextures) {
+		final ITexture[][][] rTextures = new ITexture[10][17][];
+		for (byte i = -1; i < 16; i++) {
+			rTextures[0][i + 1] = this.getFront(i);
+			rTextures[1][i + 1] = this.getBack(i);
+			rTextures[2][i + 1] = this.getBottom(i);
+			rTextures[3][i + 1] = this.getTop(i);
+			rTextures[4][i + 1] = this.getSides(i);
+			rTextures[5][i + 1] = this.getFrontActive(i);
+			rTextures[6][i + 1] = this.getBackActive(i);
+			rTextures[7][i + 1] = this.getBottomActive(i);
+			rTextures[8][i + 1] = this.getTopActive(i);
+			rTextures[9][i + 1] = this.getSidesActive(i);
+		}
+		return rTextures;
+	}
+
+	@Override
+	public ITexture[] getTexture(final IGregTechTileEntity aBaseMetaTileEntity, final byte aSide, final byte aFacing, final byte aColorIndex, final boolean aActive, final boolean aRedstone) {
+		return this.mTextures[(aActive ? 5 : 0) + (aSide == aFacing ? 0 : aSide == GT_Utility.getOppositeSide(aFacing) ? 1 : aSide == 0 ? 2 : aSide == 1 ? 3 : 4)][aColorIndex + 1];
+	}
+
+
+	public ITexture[] getFront(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+	}
+
+
+	public ITexture[] getBack(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Dimensional_Orange)};
+	}
+
+
+	public ITexture[] getBottom(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Dimensional_Orange)};
+	}
+
+
+	public ITexture[] getTop(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Screen_Logo)};
+	}
+
+
+	public ITexture[] getSides(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Dimensional_Orange)};
+	}
+
+
+	public ITexture[] getFrontActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], Textures.BlockIcons.OVERLAYS_ENERGY_OUT_MULTI[this.mTier]};
+	}
+
+
+	public ITexture[] getBackActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Dimensional_Orange)};
+	}
+
+
+	public ITexture[] getBottomActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Dimensional_Orange)};
+	}
+
+
+	public ITexture[] getTopActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Screen_Logo)};
+	}
+
+
+	public ITexture[] getSidesActive(final byte aColor) {
+		return new ITexture[]{Textures.BlockIcons.MACHINE_CASINGS[this.mTier][aColor + 1], new GT_RenderedTexture(TexturesGtBlock.Overlay_Machine_Dimensional_Orange)};
+	}
+
+	@Override
+	public IMetaTileEntity newMetaEntity(final IGregTechTileEntity aTileEntity) {
+		return new GregtechMetaPollutionDetector(this.mName, this.mTier, this.mDescription, this.mTextures, this.mInventory.length);
+	}
+
+	@Override public boolean isSimpleMachine()						{return false;}
+	@Override public boolean isElectric()							{return true;}
+	@Override public boolean isValidSlot(final int aIndex)				{return true;}
+	@Override public boolean isFacingValid(final byte aFacing)			{return true;}
+	@Override public boolean isEnetInput() 							{return true;}
+	@Override public boolean isEnetOutput() 						{return false;}
+	@Override public boolean isInputFacing(final byte aSide)				{return aSide!=this.getBaseMetaTileEntity().getFrontFacing();}
+	@Override public boolean isOutputFacing(final byte aSide)				{return aSide==this.getBaseMetaTileEntity().getFrontFacing();}
+	@Override public boolean isTeleporterCompatible()				{return false;}
+	@Override public long getMinimumStoredEU()						{return V[this.mTier]*1;}
+	@Override public long maxEUStore()								{return V[this.mTier]*1000;}
+
+	@Override
+	public long maxEUInput() {
+		return V[this.mTier];
+	}
+
+	@Override
+	public long maxEUOutput() {
+		return 0;
+	}
+
+	@Override
+	public long maxAmperesIn() {
+		return 1;
+	}
+
+	@Override
+	public long maxAmperesOut() {
+		return 0;
+	}
+	@Override public int rechargerSlotStartIndex()					{return 0;}
+	@Override public int dechargerSlotStartIndex()					{return 0;}
+	@Override public int rechargerSlotCount()						{return 0;}
+	@Override public int dechargerSlotCount()						{return 0;}
+	@Override public int getProgresstime()							{return (int)this.getBaseMetaTileEntity().getUniversalEnergyStored();}
+	@Override public int maxProgresstime()							{return (int)this.getBaseMetaTileEntity().getUniversalEnergyCapacity();}
+	@Override public boolean isAccessAllowed(final EntityPlayer aPlayer)	{return true;}
+
+	@Override
+	public boolean onRightclick(final IGregTechTileEntity aBaseMetaTileEntity, final EntityPlayer aPlayer) {
+		if (aBaseMetaTileEntity.isClientSide())
+		{
+			return true;
+		}
+		this.showPollution(aPlayer.getEntityWorld(), aPlayer);
+		return true;
+	}
+
+	private void showPollution(final World worldIn, final EntityPlayer playerIn){
+		if(!GT_Mod.gregtechproxy.mPollution){
+			PlayerUtils.messagePlayer(playerIn, "This block is useless, Pollution is disabled.");		
+		}
+		else {
+			PlayerUtils.messagePlayer(playerIn, "This chunk contains "+getCurrentChunkPollution()+" pollution.");
+			PlayerUtils.messagePlayer(playerIn, "Average over last ten minutes: "+this.mAveragePollution+" pollution.");
+		}
+	}
+
+	@Override
+	public boolean allowPullStack(final IGregTechTileEntity aBaseMetaTileEntity, final int aIndex, final byte aSide, final ItemStack aStack) {
+		return false;
+	}
+
+	@Override
+	public boolean allowPutStack(final IGregTechTileEntity aBaseMetaTileEntity, final int aIndex, final byte aSide, final ItemStack aStack) {
+		return false;
+	}
+
+	public int getCurrentChunkPollution(){
+		return getCurrentChunkPollution(this.getBaseMetaTileEntity());
+	}
+
+	public int getCurrentChunkPollution(IGregTechTileEntity aBaseMetaTileEntity){
+		return GT_Pollution.getPollution(aBaseMetaTileEntity);
+	}
+
+
+	@Override
+	public String[] getInfoData() {
+		return new String[] {
+				this.getLocalName(),
+				"Current Pollution: "+this.mCurrentPollution,
+				"Average/10 minutes:"+getAveragePollutionOverLastTen()};
+	}
+
+	@Override
+	public boolean isGivingInformation() {
+		return true;
+	}
+
+	@Override
+	public int[] getAccessibleSlotsFromSide(final int p_94128_1_) {
+		return null;
+	}
+
+	@Override
+	public boolean canInsertItem(final int p_102007_1_, final ItemStack p_102007_2_, final int p_102007_3_) {
+		return false;
+	}
+
+	@Override
+	public boolean canExtractItem(final int p_102008_1_, final ItemStack p_102008_2_, final int p_102008_3_) {
+		return false;
+	}
+
+	@Override
+	public int getSizeInventory() {
+		return 0;
+	}
+
+	@Override
+	public ItemStack getStackInSlot(final int p_70301_1_) {
+		return null;
+	}
+
+	@Override
+	public ItemStack decrStackSize(final int p_70298_1_, final int p_70298_2_) {
+		return null;
+	}
+
+	@Override
+	public ItemStack getStackInSlotOnClosing(final int p_70304_1_) {
+		return null;
+	}
+
+	@Override
+	public void setInventorySlotContents(final int p_70299_1_, final ItemStack p_70299_2_) {
+	}
+
+	@Override
+	public String getInventoryName() {
+		return null;
+	}
+
+	@Override
+	public boolean hasCustomInventoryName() {
+		return false;
+	}
+
+	@Override
+	public int getInventoryStackLimit() {
+		return 0;
+	}
+
+	@Override
+	public boolean isUseableByPlayer(final EntityPlayer p_70300_1_) {
+		return false;
+	}
+
+	@Override
+	public void openInventory() {
+	}
+
+	@Override
+	public void closeInventory() {
+	}
+
+	@Override
+	public boolean isItemValidForSlot(final int p_94041_1_, final ItemStack p_94041_2_) {
+		return false;
+	}
+
+	@Override
+	public boolean isOverclockerUpgradable() {
+		return false;
+	}
+
+	@Override
+	public boolean isTransformerUpgradable() {
+		return false;
+	}
+
+	//int mCurrentPollution;
+	//int mAveragePollution;
+	//int mAveragePollutionArray[] = new int[10];
+
+	@Override
+	public void saveNBTData(final NBTTagCompound aNBT) {
+		aNBT.setInteger("mCurrentPollution", this.mCurrentPollution);
+		aNBT.setInteger("mAveragePollution", this.mAveragePollution);
+	}
+
+	@Override
+	public void loadNBTData(final NBTTagCompound aNBT) {
+		this.mCurrentPollution = aNBT.getInteger("mCurrentPollution");
+		this.mAveragePollution = aNBT.getInteger("mAveragePollution");
+	}
+
+	@Override
+	public void onFirstTick(final IGregTechTileEntity aBaseMetaTileEntity) {
+		if (this.getBaseMetaTileEntity().isServerSide()) {
+			if (this.mCurrentPollution == 0) {
+				this.mCurrentPollution = getCurrentChunkPollution();
+			}
+			if (this.mArrayPos < 0 || this.mArrayPos > 9) {
+				this.mArrayPos = 0;
+			}
+			this.mTickTimer = 0;
+		}
+	}
+
+
+
+	@Override
+	public void onPostTick(final IGregTechTileEntity aBaseMetaTileEntity, final long aTick) {
+		super.onPostTick(aBaseMetaTileEntity, aTick);
+		if (this.getBaseMetaTileEntity().isServerSide()) {
+			//TickTimer - 20 times a second
+			if (this.mTickTimer >= 0 || this.mTickTimer <= 19){
+				this.mTickTimer++;
+			}
+			else {
+				this.mTickTimer = 0;
+				//Perform pollution update once a second
+				this.mCurrentPollution = getCurrentChunkPollution();
+				this.mSecondTimer++;
+			}
+			//Update Pollution array once a minute
+			if (this.mSecondTimer >= 60){
+				this.mSecondTimer = 0;
+				if (this.mArrayPos<this.mAveragePollutionArray.length){
+					this.mAveragePollutionArray[this.mArrayPos] = this.mCurrentPollution;
+					this.mArrayPos++;
+				}
+				else if (this.mArrayPos==this.mAveragePollutionArray.length){
+					this.mAveragePollutionArray[this.mArrayPos] = this.mCurrentPollution;
+					this.mArrayPos = 0;
+				}
+			}
+		}		
+	}
+
+	public int getAveragePollutionOverLastTen(){
+		int counter = 0;
+		int total = 0;
+		for (int i=0;i<this.mAveragePollutionArray.length;i++){
+			if (this.mAveragePollutionArray[i] != 0){
+				total += this.mAveragePollutionArray[i];
+				counter++;
+			}
+		}
+		int returnValue = 0;
+		if (total > 0 && counter > 0){
+			returnValue = (total/counter);
+			this.mAveragePollution = returnValue;
+		}
+		else {
+			returnValue = getCurrentChunkPollution();
+		}
+		return returnValue;
+	}
+
+}
\ No newline at end of file