fix a bug

5 files changed, 561 insertions, 2 deletions

diff --git a/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java b/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java
index da018675f3..bb7004350d 100644
--- a/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java
+++ b/src/Java/gtPlusPlus/core/tileentities/ModTileEntities.java
@@ -14,7 +14,8 @@ public class ModTileEntities {
 
 	public static void init() {
 		Logger.INFO("Registering Tile Entities.");
-		GameRegistry.registerTileEntity(TileEntityHeliumGenerator.class, "HeliumGenerator");
+		GameRegistry.registerTileEntity(TileEntityPooCollector.class, "TileEntityPooCollector");
+		GameRegistry.registerTileEntity(TileEntityAdvPooCollector.class, "TileEntityAdvPooCollector");
 		GameRegistry.registerTileEntity(TileEntityWorkbench.class, "TileWorkbench");
 		GameRegistry.registerTileEntity(TileEntityWorkbenchAdvanced.class, "TileWorkbenchAdvanced");
 		GameRegistry.registerTileEntity(TileEntityFishTrap.class, "TileFishTrap");
diff --git a/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java b/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java
index 0a1c53d79d..4f9a8d3748 100644
--- a/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java
+++ b/src/Java/gtPlusPlus/core/tileentities/base/TileEntityBase.java
@@ -28,6 +28,7 @@ import net.minecraftforge.fluids.IFluidHandler;
 import gtPlusPlus.api.interfaces.ILazyCoverable;
 import gtPlusPlus.api.objects.Logger;
 import gtPlusPlus.api.objects.minecraft.BTF_Inventory;
+import gtPlusPlus.core.util.data.ArrayUtils;
 import gtPlusPlus.core.util.minecraft.gregtech.PollutionUtils;
 import ic2.api.Direction;
 
@@ -81,6 +82,9 @@ public class TileEntityBase extends TileEntity implements ILazyCoverable, IGregT
 	public void updateEntity() {
 		long aTick = System.currentTimeMillis();
 		this.isDead = false;
+		if (!firstTicked) {
+			onFirstTick();			
+		}		
 		try{
 			if (this.isServerSide()){
 				onPreTick(aTick);
@@ -1297,7 +1301,22 @@ public class TileEntityBase extends TileEntity implements ILazyCoverable, IGregT
 	public boolean energyStateReady() {
 		return false;
 	}
-    
+	
+	
+	private boolean firstTicked = false;
+    	
+	public boolean onFirstTick() {
+		if (!firstTicked) {
+			firstTicked = true;
+			if (this.mInventory != null) {
+				this.mInventory.purgeNulls();
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	
 
 
 
diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityAdvPooCollector.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityAdvPooCollector.java
new file mode 100644
index 0000000000..18954f12b6
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityAdvPooCollector.java
@@ -0,0 +1,157 @@
+package gtPlusPlus.core.tileentities.machines;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.item.chemistry.AgriculturalChem;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityChicken;
+import net.minecraft.entity.passive.EntityCow;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityMooshroom;
+import net.minecraft.entity.passive.EntitySheep;
+import net.minecraft.entity.passive.EntityVillager;
+import net.minecraft.entity.passive.IAnimals;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+
+public class TileEntityAdvPooCollector extends TileEntityBaseFluidCollector {
+	
+	public TileEntityAdvPooCollector() {	
+		super(18, 128000);
+	}
+
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid) {
+		return false;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid) {
+		return true;
+	}
+	
+	public void onPreLogicTick() {
+		
+	}
+		
+	public <V> boolean addDrop(V aPooMaker) {
+		int aChance = MathUtils.randInt(0, 50000);
+		if (aChance > 0) {
+			ItemStack aPoop;
+			if (aChance<= 200) {
+				aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustManureByproducts", 1);
+			}
+			else if (aChance <= 1000) {
+				aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1);				
+			}
+			else if (aChance <= 2000) {
+				aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1);				
+			}
+			else {
+				return false;
+			}
+			
+			//Add to inventory if not full, else espawn in world
+			if (!this.mInventory.addItemStack(aPoop)) {
+				EntityItem entity = new EntityItem(worldObj, xCoord, yCoord+1.5, zCoord, aPoop);
+				worldObj.spawnEntityInWorld(entity);
+			}			
+			
+		}
+		
+		
+		return false;
+	}
+
+	private static AutoMap<Class> aEntityToDrain = new AutoMap<Class>();	
+	
+	@Override
+	public AutoMap<Class> aThingsToLookFor() {
+		if (aEntityToDrain.isEmpty()) {
+			aEntityToDrain.add(EntityAnimal.class);
+			aEntityToDrain.add(IAnimals.class);
+			aEntityToDrain.add(EntityVillager.class);
+			aEntityToDrain.add(EntityPlayer.class);
+		}
+		return aEntityToDrain;
+	}
+
+	@Override
+	public <V> int onPostTick(V aPooMaker) {
+			if (this.tank.getFluidAmount() < this.tank.getCapacity()) {				
+				int aPooAmount = 0;				
+				// Vanilla Animals
+				if (aPooMaker instanceof EntityChicken) {
+					aPooAmount = MathUtils.randInt(1, 40);
+				}
+				else if (aPooMaker instanceof EntityHorse) {
+					aPooAmount = MathUtils.randInt(20, 40);
+				}
+				else if (aPooMaker instanceof EntityCow) {
+					aPooAmount = MathUtils.randInt(18, 45);
+				}
+				else if (aPooMaker instanceof EntityMooshroom) {
+					aPooAmount = 17;
+				}
+				else if (aPooMaker instanceof EntitySheep) {
+					aPooAmount = MathUtils.randInt(8, 30);
+				}				
+				
+				else {					
+					if (aPooMaker instanceof EntityAnimal || aPooMaker instanceof IAnimals) {
+						aPooAmount = MathUtils.randInt(5, 35);						
+					}
+					else if (aPooMaker instanceof EntityVillager) {
+						aPooAmount = MathUtils.randInt(25, 30);
+					}
+					else if (aPooMaker instanceof EntityPlayer) {
+						aPooAmount = MathUtils.randInt(1, 3);
+					}
+					else {
+						aPooAmount = MathUtils.randInt(1, 10);
+					}					
+				}				
+				aPooAmount = Math.max(Math.min(this.tank.getCapacity()-this.tank.getFluidAmount(), aPooAmount), 1);				
+				return Math.max(1, (aPooAmount * MathUtils.getRandomFromArray(new int[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4}) / 10));
+			}
+			else {
+				return 0;
+			}	
+	}
+
+	@Override
+	public Fluid fluidToProvide() {
+		return AgriculturalChem.PoopJuice;
+	}
+
+	@Override
+	public Item itemToSpawnInWorldIfTankIsFull() {
+		int a = MathUtils.randInt(0, 75);
+		Item aItem = null;		
+		if (a <= 30) {
+			aItem = AgriculturalChem.dustDirt;
+		}
+		else if (a <= 40) {
+			aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustManureByproducts", 1).getItem();
+		}
+		else if (a <= 55) {
+			aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1).getItem();
+		}		
+		return aItem;
+	}
+	
+	public int getBaseTickRate() {
+		return MathUtils.randInt(50, 200);
+	}
+	
+	
+	
+
+}
diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityBaseFluidCollector.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityBaseFluidCollector.java
new file mode 100644
index 0000000000..78b8f74799
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityBaseFluidCollector.java
@@ -0,0 +1,238 @@
+package gtPlusPlus.core.tileentities.machines;
+
+import java.util.List;
+
+import gtPlusPlus.api.objects.Logger;
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.api.objects.minecraft.BTF_FluidTank;
+import gtPlusPlus.api.objects.minecraft.BlockPos;
+import gtPlusPlus.core.tileentities.base.TileEntityBase;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.FluidUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.network.NetworkManager;
+import net.minecraft.network.Packet;
+import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
+import net.minecraft.util.AxisAlignedBB;
+import net.minecraft.world.World;
+import net.minecraft.world.chunk.Chunk;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+import net.minecraftforge.fluids.FluidEvent;
+import net.minecraftforge.fluids.FluidStack;
+import net.minecraftforge.fluids.FluidTank;
+import net.minecraftforge.fluids.FluidTankInfo;
+import net.minecraftforge.fluids.IFluidHandler;
+
+public abstract class TileEntityBaseFluidCollector extends TileEntityBase implements IFluidHandler {
+
+	public final FluidTank tank;
+	private boolean needsUpdate = false;
+	private int updateTimer = 0;
+	private long internalTickCounter = 0;
+	private BlockPos internalBlockLocation;
+	
+	public TileEntityBaseFluidCollector(int aInvSlotCount, int aTankCapcity) {	
+		super(aInvSlotCount);
+		tank = new BTF_FluidTank(aTankCapcity);
+	}
+
+	@Override
+	public final int fill(ForgeDirection from, FluidStack resource, boolean doFill) {
+		needsUpdate = true;
+		return this.tank.fill(resource, doFill);
+	}
+
+	@Override
+	public final FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain) {
+		needsUpdate = true;
+		return this.tank.drain(resource.amount, doDrain);
+	}
+
+	@Override
+	public final FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain) {
+		needsUpdate = true;
+		FluidStack fluid = this.tank.getFluid();
+		// return this.tank.drain(maxDrain, doDrain);
+		if (fluid == null) {
+			return null;
+		}
+
+		int drained = maxDrain;
+		if (fluid.amount < drained) {
+			drained = fluid.amount;
+		}
+
+		FluidStack stack = new FluidStack(fluid, drained);
+		if (doDrain) {
+			fluid.amount -= drained;
+			if (fluid.amount <= 0) {
+				fluid = null;
+			}
+
+			if (this != null) {
+				FluidEvent.fireEvent(new FluidEvent.FluidDrainingEvent(fluid, this.getWorldObj(), this.xCoord,
+						this.yCoord, this.zCoord, this.tank, 0));
+			}
+		}
+		return stack;
+	}
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid) {
+		return false;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid) {
+		return true;
+	}
+
+	@Override
+	public final FluidTankInfo[] getTankInfo(ForgeDirection from) {
+		return new FluidTankInfo[] { this.tank.getInfo() };
+	}
+
+	@Override
+	public final void updateEntity() {		
+		super.updateEntity();
+		onPreLogicTick();
+		logicTick();		
+		if (needsUpdate) {			
+			if (updateTimer == 0) {
+				updateTimer = 10; // every 10 ticks it will send an update
+			} else {
+				--updateTimer;
+				if (updateTimer == 0) {
+					worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
+					needsUpdate = false;
+				}
+			}
+		}
+	}
+
+	@Override
+	public void readFromNBT(NBTTagCompound tag) {
+		tank.readFromNBT(tag);
+		super.readFromNBT(tag);
+	}
+
+	@Override
+	public void writeToNBT(NBTTagCompound tag) {
+		tank.writeToNBT(tag);
+		super.writeToNBT(tag);
+	}
+
+	@Override
+	public final Packet getDescriptionPacket() {
+		NBTTagCompound tag = new NBTTagCompound();
+		writeToNBT(tag);
+		return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.blockMetadata, tag);
+	}
+
+	@Override
+	public final void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
+		NBTTagCompound tag = pkt.func_148857_g();
+		readFromNBT(tag);
+	}
+	
+	public int getBaseTickRate() {
+		return MathUtils.randInt(200, 300);
+	}
+	
+	public abstract AutoMap<Class> aThingsToLookFor();
+	
+	public abstract void onPreLogicTick();
+	
+	public final void logicTick() {
+
+		if (this.worldObj == null || this.worldObj.isRemote) {
+			return;
+		}
+		if (internalTickCounter % getBaseTickRate() == 0) {
+			if (internalBlockLocation == null) {
+				internalBlockLocation = new BlockPos(this);
+			}
+			BlockPos p = internalBlockLocation;
+			if (p != null) {
+				if (p.world != null) {
+					World w = this.worldObj;
+					if (w == null) {
+						return;
+					}
+					Chunk c = w.getChunkFromBlockCoords(p.xPos, p.zPos);
+					if (c != null) {
+						if (c.isChunkLoaded) {
+							int startX = p.xPos - 2;
+							int startY = p.yPos;
+							int startZ = p.zPos - 2;
+							int endX = p.xPos + 3;
+							int endY = p.yPos + 5;
+							int endZ = p.zPos + 3;
+							AxisAlignedBB box = AxisAlignedBB.getBoundingBox(startX, startY, startZ, endX, endY, endZ);
+							if (box != null) {								
+								for (Class c2 : aThingsToLookFor()) {
+									tickEntityType(w, box, c2);										
+								}														
+							} else {
+								return;
+							}
+						}
+					}
+				}
+			}
+
+		}
+
+		internalTickCounter++;
+	}
+	
+	@SuppressWarnings("unchecked")
+	public final void tickEntityType(World w, AxisAlignedBB box, Class aClassToFind) {
+		List<?> entities = w.getEntitiesWithinAABB(aClassToFind, box);	
+		if (entities != null && !entities.isEmpty()) {
+			interactWithEntities(entities);
+		}
+	}
+	
+	public final <V> void interactWithEntities(List<V> entities) {
+		for (V aEntity : entities) {
+			addDrop(aEntity);
+			if (this.tank.getFluidAmount() < this.tank.getCapacity()) {				
+				int aFluidAmount = onPostTick(aEntity);								
+				aFluidAmount = Math.max(Math.min(this.tank.getCapacity()-this.tank.getFluidAmount(), aFluidAmount), 1);				
+				this.tank.fill(FluidUtils.getFluidStack(fluidToProvide(), aFluidAmount), true);
+			}
+			else {
+				ItemStack aDirtStack = ItemUtils.getSimpleStack(itemToSpawnInWorldIfTankIsFull());
+				if (aDirtStack != null)
+				if (!this.mInventory.addItemStack(aDirtStack)) {
+					EntityItem entity = new EntityItem(worldObj, xCoord, yCoord+1.5, zCoord, aDirtStack);
+					worldObj.spawnEntityInWorld(entity);
+				}
+			}
+		}	
+	}
+	
+
+	/**
+	 * Return the amount of fluid for this entity type
+	 * @param aEntity
+	 * @return
+	 */
+	public abstract <V> int onPostTick(V aEntity);
+	
+	public abstract <V> boolean addDrop(V aPooMaker);
+	
+	public abstract Fluid fluidToProvide();
+	
+	public abstract Item itemToSpawnInWorldIfTankIsFull();
+	
+	
+	
+
+}
diff --git a/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityPooCollector.java b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityPooCollector.java
new file mode 100644
index 0000000000..f6570c6cc6
--- /dev/null
+++ b/src/Java/gtPlusPlus/core/tileentities/machines/TileEntityPooCollector.java
@@ -0,0 +1,144 @@
+package gtPlusPlus.core.tileentities.machines;
+
+import gtPlusPlus.api.objects.data.AutoMap;
+import gtPlusPlus.core.item.chemistry.AgriculturalChem;
+import gtPlusPlus.core.util.math.MathUtils;
+import gtPlusPlus.core.util.minecraft.ItemUtils;
+import net.minecraft.entity.item.EntityItem;
+import net.minecraft.entity.passive.EntityAnimal;
+import net.minecraft.entity.passive.EntityChicken;
+import net.minecraft.entity.passive.EntityCow;
+import net.minecraft.entity.passive.EntityHorse;
+import net.minecraft.entity.passive.EntityMooshroom;
+import net.minecraft.entity.passive.EntitySheep;
+import net.minecraft.entity.passive.IAnimals;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.common.util.ForgeDirection;
+import net.minecraftforge.fluids.Fluid;
+
+public class TileEntityPooCollector extends TileEntityBaseFluidCollector {
+	
+	public TileEntityPooCollector() {	
+		super(9, 8000);
+	}
+
+
+	@Override
+	public boolean canFill(ForgeDirection from, Fluid fluid) {
+		return false;
+	}
+
+	@Override
+	public boolean canDrain(ForgeDirection from, Fluid fluid) {
+		return true;
+	}
+	
+	public void onPreLogicTick() {
+		
+	}
+		
+	public <V> boolean addDrop(V aPooMaker) {
+		int aChance = MathUtils.randInt(0, 50000);
+		if (aChance > 0) {
+			ItemStack aPoop;
+			if (aChance<= 100) {
+				aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustManureByproducts", 1);
+			}
+			else if (aChance <= 500) {
+				aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1);				
+			}
+			else if (aChance <= 1250) {
+				aPoop = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1);				
+			}
+			else {
+				return false;
+			}
+			//Add poop to world
+			//Logger.INFO("Adding animal waste for "+aPooMaker.getCommandSenderName());
+			
+			//Add to inventory if not full, else espawn in world
+			if (!this.mInventory.addItemStack(aPoop)) {
+				EntityItem entity = new EntityItem(worldObj, xCoord, yCoord+1.5, zCoord, aPoop);
+				worldObj.spawnEntityInWorld(entity);
+			}			
+			
+		}
+		
+		
+		return false;
+	}
+
+	private static AutoMap<Class> aEntityToDrain = new AutoMap<Class>();	
+	
+	@Override
+	public AutoMap<Class> aThingsToLookFor() {
+		if (aEntityToDrain.isEmpty()) {
+			aEntityToDrain.add(EntityAnimal.class);
+			aEntityToDrain.add(IAnimals.class);
+		}
+		return aEntityToDrain;
+	}
+
+	@Override
+	public <V> int onPostTick(V aPooMaker) {
+			if (this.tank.getFluidAmount() < this.tank.getCapacity()) {				
+				int aPooAmount = 0;				
+				// Vanilla Animals
+				if (aPooMaker instanceof EntityChicken) {
+					aPooAmount = MathUtils.randInt(1, 40);
+				}
+				else if (aPooMaker instanceof EntityHorse) {
+					aPooAmount = MathUtils.randInt(20, 40);
+				}
+				else if (aPooMaker instanceof EntityCow) {
+					aPooAmount = MathUtils.randInt(18, 45);
+				}
+				else if (aPooMaker instanceof EntityMooshroom) {
+					aPooAmount = 17;
+				}
+				else if (aPooMaker instanceof EntitySheep) {
+					aPooAmount = MathUtils.randInt(8, 30);
+				}				
+				
+				else {					
+					if (aPooMaker instanceof EntityAnimal || aPooMaker instanceof IAnimals) {
+						aPooAmount = MathUtils.randInt(5, 35);						
+					}
+					else {
+						aPooAmount = MathUtils.randInt(1, 10);
+					}					
+				}				
+				aPooAmount = Math.max((Math.min(this.tank.getCapacity()-this.tank.getFluidAmount(), aPooAmount)/10), 1);				
+				return aPooAmount;
+			}
+			else {
+				return 0;
+			}	
+	}
+
+	@Override
+	public Fluid fluidToProvide() {
+		return AgriculturalChem.PoopJuice;
+	}
+
+	@Override
+	public Item itemToSpawnInWorldIfTankIsFull() {
+		int a = MathUtils.randInt(0, 100);
+		Item aItem = null;		
+		if (a <= 30) {
+			aItem = AgriculturalChem.dustDirt;
+		}
+		else if (a <= 40) {
+			aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustSmallManureByproducts", 1).getItem();
+		}
+		else if (a <= 55) {
+			aItem = ItemUtils.getItemStackOfAmountFromOreDict("dustTinyManureByproducts", 1).getItem();
+		}		
+		return aItem;
+	}
+	
+	
+	
+
+}