Minecraft Forums

 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Set;

import ryan.mod.utils.BlockCoords;
import ryan.mod.utils.FluidUtils;
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.tileentity.TileEntity;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.Fluid;
import net.minecraftforge.fluids.FluidStack;
import net.minecraftforge.fluids.FluidTank;
import net.minecraftforge.fluids.FluidTankInfo;
import net.minecraftforge.fluids.IFluidHandler;

public class TileEntityBasicPipe extends TileEntity implements IFluidHandler{

public FluidTank tank = new FluidTank(1000);
 public boolean needsUpdate = false;
 private int updateTimer = 0;
 public ForgeDirection lastProvider;
 public ArrayList<ForgeDirection> validOutputs = new ArrayList();
 public HashMap<ForgeDirection, FluidTank> subTanks = new HashMap();
 public ForgeDirection lastProvidie;


 public TileEntityBasicPipe() {
 
 
 lastProvider = ForgeDirection.UNKNOWN;
 lastProvidie = ForgeDirection.UNKNOWN;
 
 validOutputs.add(ForgeDirection.DOWN);
 validOutputs.add(ForgeDirection.EAST);
 validOutputs.add(ForgeDirection.NORTH);
 validOutputs.add(ForgeDirection.SOUTH);
 validOutputs.add(ForgeDirection.UP);
 validOutputs.add(ForgeDirection.WEST);
 
 subTanks.put(ForgeDirection.UP, new FluidTank(100));
 subTanks.put(ForgeDirection.DOWN, new FluidTank(100));
 subTanks.put(ForgeDirection.NORTH, new FluidTank(100));
 subTanks.put(ForgeDirection.SOUTH, new FluidTank(100));
 subTanks.put(ForgeDirection.EAST, new FluidTank(100));
 subTanks.put(ForgeDirection.WEST, new FluidTank(100));
 
 }
 
 
 
 public int fill(ForgeDirection from, FluidStack resource, boolean doFill)
 {
 needsUpdate = true;
 if(doFill)
 {
 
 lastProvider = from;
 }
 for(ForgeDirection dire : validOutputs){
 if(from == dire)
 {
 return this.subTanks.get(from).fill(resource, doFill);
 
 }
 else
 {
 return this.tank.fill(resource, doFill);
 }
 }
 
 return 0;
 }
 
 public FluidStack drain(ForgeDirection from, FluidStack resource, boolean doDrain)
 {
 if(doDrain)
 {
 lastProvidie = from;
 }
 
 if(resource != null && !resource.isFluidEqual(tank.getFluid())){
 
 return null;
 }
 
 return this.tank.drain(resource.amount, doDrain);
 }
 
 public FluidStack drain(ForgeDirection from, int maxDrain, boolean doDrain)
 {
 if(doDrain)
 {
 lastProvidie = from;
 }
 
 
 return this.subTanks.get(from).drain(maxDrain, doDrain);
 
 
}
 
 public boolean canFill(ForgeDirection from, Fluid fluid)
 {
 return true;
 }
 
 public boolean canDrain(ForgeDirection from, Fluid fluid)
 {
 return true;
 }
 
 public FluidTankInfo[] getTankInfo(ForgeDirection from)
 {
 return new FluidTankInfo[] {this.tank.getInfo()};
 }
 
 public float getAdjustedVolume()
 {
 float amount = tank.getFluidAmount();
 float capacity = tank.getCapacity();
 float volume = (amount/capacity)*0.8F; 
 return volume;
 }
 
 
 
 
 public void updateEntity() 
 {
 needsUpdate = true;
 if (needsUpdate) 
 {
 if (updateTimer == 0) 
 { 
 updateTimer = 16; // every 10 tick(s) it will send an update
 } 
 else 
 { 
 --updateTimer;
 if (updateTimer == 0) 
 { 
 //drainFromTanks();
 distrubeLiquids();
 outputLiquids();
 worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
 needsUpdate = false;
 }
 }
 }
 }
 
 @Override
 public void readFromNBT(NBTTagCompound tag)
 {
 super.readFromNBT(tag);
 tank.readFromNBT(tag);
 }

@Override
 public void writeToNBT(NBTTagCompound tag)
 {
 super.writeToNBT(tag);
 tank.writeToNBT(tag);
 
 
 }
 
 @Override
 public Packet getDescriptionPacket()
 {
 NBTTagCompound tag = new NBTTagCompound();
 writeToNBT(tag);
 return new S35PacketUpdateTileEntity(this.xCoord, this.yCoord, this.zCoord, this.blockMetadata, tag);
 }

@Override
 public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt)
 {
 NBTTagCompound tag = pkt.func_148857_g();
 readFromNBT(tag);
 }

public void changeOutputs(){
 
 
 for(ForgeDirection dire : ForgeDirection.VALID_DIRECTIONS){
 TileEntity tile = this.worldObj.getTileEntity(xCoord + dire.offsetX, yCoord + dire.offsetY, zCoord + dire.offsetZ);
 if(tile != null && tile instanceof IFluidHandler){
 validOutputs.clear();
 validOutputs.add(dire);
 
 
 
 }
 
 }
 
 
 }
 
 public ForgeDirection getForgeDirection(ForgeDirection dire, Fluid fluid){
 return canFill(dire, fluid) ? dire.getOpposite() : ForgeDirection.UNKNOWN;
 }


 
 public void drainFromTanks(){
 Set<ForgeDirection> connections = this.getOutputs().keySet();
 Fluid f = tank.getFluid() == null ? null : tank.getFluid().getFluid();
 for (ForgeDirection dir : connections) {

IFluidHandler extTank = FluidUtils.getExternalTanks(worldObj, new BlockCoords(xCoord + dir.offsetX, yCoord + dir.offsetY, zCoord + dir.offsetZ));
 if(extTank != null) {

boolean foundFluid = false;
 FluidTankInfo[] info = extTank.getTankInfo(dir.getOpposite());
 if(info != null) {
 for (FluidTankInfo inf : info) {
 if(inf != null && inf.fluid != null && inf.fluid.amount > 0) {
 foundFluid = true;
 }
 }
 }
 if(!foundFluid) {
 return;
 }
 FluidStack couldDrain = extTank.drain(dir, 100, false);
 if(couldDrain != null && couldDrain.amount > 0 && canFill(dir, couldDrain.getFluid()))
 {
 int used = fill(dir.getOpposite(), couldDrain, false);
 if(used > 0)
 used = extTank.drain(dir, 100, true).amount;
 
 couldDrain.amount = used;
 used = fill(dir, couldDrain, true);
 
 
 }
 }
 }
 }
 
 
 
 
 
 
 
 

public synchronized void distrubeLiquids() {
 Set<ForgeDirection> connected = this.getOutputs().keySet();


 if (connected.contains(lastProvider))
 connected.remove(lastProvider);

int output = Math.min(tank.getFluidAmount(), 100);
 int connectedAmount = connected.size();
 if (connectedAmount < 1)
 connectedAmount = 1;
 int scaledAmount = output / connectedAmount;

for (ForgeDirection dirOut : connected)
 {
 if (this.tank.getFluid() == null)
 break;

/* DEBUG
 debugLog.add("Moving to "+dirOut+"ern SubTank");
 */
 FluidStack tempFS = new FluidStack(tank.getFluid().getFluid(), scaledAmount);
 int fit = subTanks.get(dirOut).fill(tempFS, false);
 /* DEBUG
 debugLog.add("SubTank will accept "+fit+"mb");
 */
 if (fit > 0)
 fit = tank.drain(fit, true).amount;
 /* DEBUG
 debugLog.add("Internal Tank was drained by "+fit+"mb");
 */
 tempFS.amount = fit;
 fit = subTanks.get(dirOut).fill(tempFS, true);
 /* DEBUG
 debugLog.add("SubTank was filled by "+fit+"mb");
 if(fit > 0)
 printDebugLog = true;
 debugLog.add("Internal Tank now contains: "+internalTank.getFluidAmount()+"mb");
 debugLog.add("SubTank now contains: "+subTanks.get(dirOut).getFluidAmount()+"mb");
 */
 
 }
 /* DEBUG
 if(printDebugLog)
 {
 for(String s: debugLog)
 System.out.println(s);
 debugLog.clear();
 }
 printDebugLog = false;
 */

//Get Fluid from most recent InputTank
 FluidTank inputTank = subTanks.get(lastProvider);
 if (inputTank != null && inputTank.getFluid() != null) //Tank can be null if input was received from top
 {
 /* DEBUG
 debugLog.add("Importing from "+lastProvider+"ern SubTank");
 */
 FluidStack tempFS = new FluidStack(inputTank.getFluid().getFluid(), Math.min(inputTank.getFluidAmount(), 100));
 int fit = tank.fill(tempFS, false);
 /* DEBUG
 debugLog.add("Internal Tank will accept "+fit+"mb");
 */
 if (fit > 0)
 fit = inputTank.drain(fit, true).amount;
 /* DEBUG
 debugLog.add("Import Tank was drained by "+fit+"mb");
 */
 tempFS.amount = fit;
 fit = tank.fill(tempFS, true);
 
 markForUpdate();
 }
 
 
 }
 
 public synchronized void outputLiquids() {
 
 HashMap<ForgeDirection, TileEntity> connected = this.getOutputs();
 if(connected.containsKey(lastProvider)){
 connected.remove(lastProvider);
 }
 
 
 
 if(connected.size() != 0)
 {
 for(ForgeDirection dire : connected.keySet())
 {
 if(subTanks.get(dire) != null && subTanks.get(dire).getFluid() != null){
 
 FluidStack fluid = new FluidStack(subTanks.get(dire).getFluid().getFluid(), Math.min(subTanks.get(dire).getFluidAmount(), 100));
 int fit = ((IFluidHandler)connected.get(dire)).fill(dire.getOpposite(), fluid, false);
 if(fit > 0)
 
 fit = this.drain(dire, fit, true).amount;
 
 fluid.amount = fit;
 fit = ((IFluidHandler)connected.get(dire)).fill(dire.getOpposite(), fluid, true);
 
 
 }
 
 
 }
 
 }
 
 
 }
 
 public void markForUpdate(){
 
 this.worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
 
 }


 public HashMap<ForgeDirection, TileEntity> getOutputs() {
 HashMap<ForgeDirection, TileEntity> map = new HashMap();
 for(ForgeDirection dire : validOutputs){
 TileEntity tile = this.worldObj.getTileEntity(xCoord + dire.offsetX, yCoord + dire.offsetY, zCoord + dire.offsetZ);
 if(tile != null && tile instanceof IFluidHandler){
 map.put(dire, tile);
 //System.out.println("Tank at: " + dire);
 }
 
 }
 return map;
 
 }

 


 
 
 
 
 
 
}

 @Override
public boolean onBlockActivated(World world, int x, int y, int z, EntityPlayer player, int par6, float par7, float par8, float par9) {

ItemStack stack = player.inventory.getCurrentItem();
if (stack != null) {

FluidStack liquid = FluidContainerRegistry.getFluidForFilledItem(stack);
TileEntityBasicTank tank = (TileEntityBasicTank) world.getTileEntity(x, y, z);

if (liquid != null) {

int amount = tank.fill(ForgeDirection.UNKNOWN, liquid, false);

if (amount == liquid.amount) {

tank.fill(ForgeDirection.UNKNOWN, liquid, true);
if (!player.capabilities.isCreativeMode)
player.inventory.setInventorySlotContents(player.inventory.currentItem, Utilities.useItemSafely(stack));

return true;
}

else
return true;
}

else if (FluidContainerRegistry.isBucket(stack)) {

FluidTankInfo[] tanks = tank.getTankInfo(ForgeDirection.UNKNOWN);

if (tanks[0] != null) {

FluidStack fillFluid = tanks[0].fluid;
ItemStack fillStack = FluidContainerRegistry.fillFluidContainer(fillFluid, stack);

if (fillStack != null) {

tank.drain(ForgeDirection.UNKNOWN, FluidContainerRegistry.getFluidForFilledItem(fillStack).amount, true);

if (!player.capabilities.isCreativeMode) {

if (stack.stackSize == 1)
player.inventory.setInventorySlotContents(player.inventory.currentItem, fillStack);

else {
player.inventory.setInventorySlotContents(player.inventory.currentItem, Utilities.useItemSafely(stack));

if (!player.inventory.addItemStackToInventory(fillStack))
player.dropPlayerItemWithRandomChoice(fillStack, false);
}
}
return true;
}

else
return true;
}
}
}

return false;
}

/*
*** MADE BY MITHION'S .SCHEMATIC TO JAVA CONVERTING TOOL v1.6 ***
*/
package theRobots.structures;
import java.util.Random;
import theRobots.RobotBase;
import theRobots.TileEntity.TileEntityAltar;
import net.minecraft.block.Block;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.world.World;
import net.minecraft.world.gen.feature.WorldGenerator;
public class BasicDungeon extends WorldGenerator
{
protected int[] GetValidSpawnBlocks() {
  return new int[] {
   Block.stone.blockID,
   Block.grass.blockID,
   Block.dirt.blockID,
   Block.cobblestone.blockID,
   Block.sand.blockID,
   Block.gravel.blockID
  };
}
public boolean LocationIsValidSpawn(World world, int i, int j, int k){
  int distanceToAir = 0;
  int checkID = world.getBlockId(i, j, k);
  while (checkID != 0){
   distanceToAir++;
   checkID = world.getBlockId(i, j + distanceToAir, k);
  }
  if (distanceToAir > 1){
   return false;
  }
  j += distanceToAir - 1;
  int blockID = world.getBlockId(i, j, k);
  int blockIDAbove = world.getBlockId(i, j+1, k);
  int blockIDBelow = world.getBlockId(i, j-1, k);
  for (int x : GetValidSpawnBlocks()){
   if (blockIDAbove != 0){
    return false;
   }
   if (blockID == x){
    return true;
   }else if (blockID == Block.snow.blockID && blockIDBelow == x){
    return true;
   }
  }
  return false;
}
public BasicDungeon() { }
public boolean generate(World world, Random rand, int i, int j, int k) {
  //check that each corner is one of the valid spawn blocks
  if(!LocationIsValidSpawn(world, i, j, k) || !LocationIsValidSpawn(world, i + 10, j, k) || !LocationIsValidSpawn(world, i + 10, j, k + 10) || !LocationIsValidSpawn(world, i, j, k + 10))
  {
   return false;
  }
//after some world.setBlock(x, y, z, Block.BlockID);