Files
TinkersConstruct/src/main/java/tconstruct/smeltery/logic/SmelteryLogic.java
T

1269 lines
40 KiB
Java

package tconstruct.smeltery.logic;
import cpw.mods.fml.relauncher.*;
import java.util.*;
import mantle.blocks.abstracts.*;
import mantle.blocks.iface.*;
import mantle.world.CoordTuple;
import net.minecraft.block.Block;
import net.minecraft.entity.*;
import net.minecraft.entity.item.EntityItem;
import net.minecraft.entity.monster.*;
import net.minecraft.entity.passive.*;
import net.minecraft.entity.player.*;
import net.minecraft.init.Blocks;
import net.minecraft.inventory.Container;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.*;
import net.minecraft.network.*;
import net.minecraft.network.play.server.S35PacketUpdateTileEntity;
import net.minecraft.tileentity.TileEntity;
import net.minecraft.util.*;
import net.minecraft.world.World;
import net.minecraftforge.common.util.ForgeDirection;
import net.minecraftforge.fluids.*;
import tconstruct.library.crafting.Smeltery;
import tconstruct.smeltery.*;
import tconstruct.smeltery.inventory.SmelteryContainer;
import tconstruct.util.config.PHConstruct;
/* Simple class for storing items in the block
*/
public class SmelteryLogic extends InventoryLogic implements IActiveLogic, IFacingLogic, IFluidTank, IMasterLogic
{
private static final int MAX_SMELTERY_SIZE = 7;
public boolean validStructure;
public boolean tempValidStructure;
protected byte direction;
public CoordTuple minPos = new CoordTuple(0, 0, 0);
public CoordTuple maxPos = new CoordTuple(0, 0, 0);
public int layers;
public int maxBlockCapacity;
protected int internalTemp;
public int useTime;
public int fuelGague;
public int fuelAmount;
protected boolean inUse;
protected ArrayList<CoordTuple> lavaTanks;
protected CoordTuple activeLavaTank;
public int[] activeTemps; // values are multiplied by 10
public int[] meltingTemps; // values are multiplied by 10
private int tick;
public ArrayList<FluidStack> moltenMetal = new ArrayList<FluidStack>();
public int maxLiquid;
public int currentLiquid;
Random rand = new Random();
boolean needsUpdate;
public SmelteryLogic()
{
super(0);
lavaTanks = new ArrayList<CoordTuple>();
activeTemps = new int[0];
meltingTemps = new int[0];
}
public int getBlocksPerLayer()
{
int xd = maxPos.x - minPos.x + 1;
int zd = maxPos.z - minPos.z + 1;
return xd * zd;
}
public int getBlockCapacity()
{
return maxBlockCapacity;
}
void adjustLayers (int lay, boolean forceAdjust)
{
if (lay != layers || forceAdjust)
{
needsUpdate = true;
layers = lay;
maxBlockCapacity = getBlocksPerLayer() * layers;
maxLiquid = 20000 * lay;
int[] tempActive = activeTemps;
activeTemps = new int[maxBlockCapacity];
int activeLength = tempActive.length > activeTemps.length ? activeTemps.length : tempActive.length;
System.arraycopy(tempActive, 0, activeTemps, 0, activeLength);
int[] tempMelting = meltingTemps;
meltingTemps = new int[maxBlockCapacity];
int meltingLength = tempMelting.length > meltingTemps.length ? meltingTemps.length : tempMelting.length;
System.arraycopy(tempMelting, 0, meltingTemps, 0, meltingLength);
ItemStack[] tempInv = inventory;
inventory = new ItemStack[maxBlockCapacity];
int invLength = tempInv.length > inventory.length ? inventory.length : tempInv.length;
System.arraycopy(tempInv, 0, inventory, 0, invLength);
if (activeTemps.length > 0 && activeTemps.length > tempActive.length)
{
for (int i = tempActive.length; i < activeTemps.length; i++)
{
activeTemps[i] = 200;
meltingTemps[i] = 200;
}
}
if (tempInv.length > inventory.length)
{
for (int i = inventory.length; i < tempInv.length; i++)
{
ItemStack stack = tempInv[i];
if (stack != null)
{
float jumpX = rand.nextFloat() * 0.8F + 0.1F;
float jumpY = rand.nextFloat() * 0.8F + 0.1F;
float jumpZ = rand.nextFloat() * 0.8F + 0.1F;
int offsetX = 0;
int offsetZ = 0;
switch (getRenderDirection())
{
case 2: // +z
offsetZ = -1;
break;
case 3: // -z
offsetZ = 1;
break;
case 4: // +x
offsetX = -1;
break;
case 5: // -x
offsetX = 1;
break;
}
while (stack.stackSize > 0)
{
int itemSize = rand.nextInt(21) + 10;
if (itemSize > stack.stackSize)
{
itemSize = stack.stackSize;
}
stack.stackSize -= itemSize;
EntityItem entityitem = new EntityItem(worldObj, (double) ((float) xCoord + jumpX + offsetX), (double) ((float) yCoord + jumpY), (double) ((float) zCoord + jumpZ + offsetZ), new ItemStack(stack.getItem(), itemSize, stack.getItemDamage()));
if (stack.hasTagCompound())
{
entityitem.getEntityItem().setTagCompound((NBTTagCompound) stack.getTagCompound().copy());
}
float offset = 0.05F;
entityitem.motionX = (double) ((float) rand.nextGaussian() * offset);
entityitem.motionY = (double) ((float) rand.nextGaussian() * offset + 0.2F);
entityitem.motionZ = (double) ((float) rand.nextGaussian() * offset);
worldObj.spawnEntityInWorld(entityitem);
}
}
}
}
}
}
/* Misc */
@Override
public String getDefaultName ()
{
return "crafters.Smeltery";
}
@Override
public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z)
{
return new SmelteryContainer(inventoryplayer, this);
}
@Override
public byte getRenderDirection ()
{
return direction;
}
@Override
public ForgeDirection getForgeDirection ()
{
return ForgeDirection.VALID_DIRECTIONS[direction];
}
@Override
public void setDirection (int side)
{
}
@Override
public void setDirection (float yaw, float pitch, EntityLivingBase player)
{
int facing = MathHelper.floor_double((double) (yaw / 360) + 0.5D) & 3;
switch (facing)
{
case 0:
direction = 2;
break;
case 1:
direction = 5;
break;
case 2:
direction = 3;
break;
case 3:
direction = 4;
break;
}
}
@Override
public boolean getActive ()
{
return validStructure;
}
@Override
public void setActive (boolean flag)
{
needsUpdate = true;
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
public int getScaledFuelGague (int scale)
{
int ret = (fuelGague * scale) / 52;
if (ret < 1)
ret = 1;
return ret;
}
public int getInternalTemperature ()
{
if (!validStructure)
return 20;
return internalTemp;
}
public int getTempForSlot (int slot)
{
return activeTemps[slot] / 10;
}
public int getMeltingPointForSlot (int slot)
{
return meltingTemps[slot] / 10;
}
/* Updating */
@Override
public void updateEntity ()
{
/*
* if (worldObj.isRemote) return;
*/
tick++;
if (tick % 4 == 0)
heatItems();
if (tick % 20 == 0)
{
if (!validStructure)
checkValidPlacement();
if (useTime > 0 && inUse)
useTime -= 3;
if (validStructure && useTime <= 0)
{
updateFuelGague();
}
if (needsUpdate)
{
needsUpdate = false;
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
}
}
if (tick == 60)
{
tick = 0;
detectEntities();
}
}
void detectEntities ()
{
// todo: fix this with min-max pos instead of center pos
if (minPos == null || maxPos == null)
return;
AxisAlignedBB box = AxisAlignedBB.getBoundingBox(minPos.x, minPos.y, minPos.z, maxPos.x+1, minPos.y + layers, maxPos.z+1);
List list = worldObj.getEntitiesWithinAABB(Entity.class, box);
for (Object o : list)
{
if (moltenMetal.size() >= 1)
{
if (o instanceof EntityVillager)
{
EntityVillager villager = (EntityVillager) o;
if (villager.attackEntityFrom(new SmelteryDamageSource(), 5))
{
if (currentLiquid + 40 < maxLiquid)
{
int amount = villager.isChild() ? 5 : 40;
this.fill(new FluidStack(TinkerSmeltery.moltenEmeraldFluid, amount), true);
}
}
}
else if (o instanceof EntityEnderman)
{
EntityEnderman villager = (EntityEnderman) o;
if (villager.attackEntityFrom(new SmelteryDamageSource(), 5))
{
if (currentLiquid + 125 < maxLiquid)
{
this.fill(new FluidStack(TinkerSmeltery.moltenEnderFluid, 125), true);
}
}
}
else if (o instanceof EntityIronGolem)
{
EntityIronGolem golem = (EntityIronGolem) o;
if (golem.attackEntityFrom(new SmelteryDamageSource(), 5))
{
if (currentLiquid + 40 < maxLiquid)
{
this.fill(new FluidStack(TinkerSmeltery.moltenIronFluid, 40), true);
}
}
}
else if (o instanceof EntityHorse)
{
EntityHorse horse = (EntityHorse) o;
if (PHConstruct.meltableHorses && horse.attackEntityFrom(new SmelteryDamageSource(), 5))
{
if (currentLiquid + 108 < maxLiquid)
{
this.fill(new FluidStack(TinkerSmeltery.glueFluid, 108), true);
}
}
}
else if (o instanceof EntityLivingBase)
{
EntityLivingBase living = (EntityLivingBase) o;
if (living.attackEntityFrom(new SmelteryDamageSource(), 5))
{
if (currentLiquid + 40 < maxLiquid)
{
int amount = (living.isChild() || living instanceof EntityPlayer) ? 5 : 40;
this.fill(new FluidStack(TinkerSmeltery.bloodFluid, amount), true);
}
}
}
}
else if (PHConstruct.throwableSmeltery && o instanceof EntityItem)
{
handleItemEntity((EntityItem) o);
}
}
}
private void handleItemEntity (EntityItem item)
{
// Clients like to play merry hell with this and cause breakage (we
// update their inv on syncs)
if (worldObj.isRemote)
return;
item.age = 0;
ItemStack istack = item.getEntityItem();
if (istack == null || istack.stackSize <= 0) // Probably most definitely
// not necessary
return;
int maxSlot = this.getSizeInventory();
boolean itemDestroyed = false;
boolean itemAdded = false;
for (int i = 0; i < maxSlot; i++)
{
ItemStack stack = this.getStackInSlot(i);
if (stack == null && istack.stackSize > 0)
{
ItemStack copy = istack.splitStack(1);
this.setInventorySlotContents(i, copy);
itemAdded = true;
if (istack.stackSize <= 0)
{
item.setDead();
itemDestroyed = true;
break;
}
}
}
if (!itemDestroyed)
item.setEntityItemStack(istack);
if (itemAdded)
{
this.needsUpdate = true;
//TODO 1.7.5 send description packet in better way to not cause render update
this.worldObj.markBlockForUpdate(this.xCoord, this.yCoord, this.zCoord);
}
}
private void heatItems ()
{
if (useTime > 0)
{
boolean hasUse = false;
int temperature = this.getInternalTemperature();
int speed = temperature / 100;
int refTemp = temperature * 10;
for (int i = 0; i < maxBlockCapacity; i++)
{
if (meltingTemps[i] > 200 && this.isStackInSlot(i))
{
hasUse = true;
if (activeTemps[i] < refTemp && activeTemps[i] < meltingTemps[i])
{
activeTemps[i] += speed; // lava has temp of 1000. we increase by 10 per application.
}
else if (activeTemps[i] >= meltingTemps[i])
{
if (!worldObj.isRemote)
{
FluidStack result = getResultFor(inventory[i]);
if (result != null)
{
if (addMoltenMetal(result, false))
{
inventory[i] = null;
activeTemps[i] = 200;
ArrayList alloys = Smeltery.mixMetals(moltenMetal);
for (int al = 0; al < alloys.size(); al++)
{
FluidStack liquid = (FluidStack) alloys.get(al);
addMoltenMetal(liquid, true);
}
markDirty();
}
}
}
}
}
else
activeTemps[i] = 200;
}
inUse = hasUse;
}
}
boolean addMoltenMetal (FluidStack liquid, boolean first)
{
needsUpdate = true;
if (moltenMetal.size() == 0)
{
moltenMetal.add(liquid.copy());
currentLiquid += liquid.amount;
return true;
}
else
{
if (liquid.amount + currentLiquid > maxLiquid)
return false;
currentLiquid += liquid.amount;
// TConstruct.logger.info("Current liquid: "+currentLiquid);
boolean added = false;
for (int i = 0; i < moltenMetal.size(); i++)
{
FluidStack l = moltenMetal.get(i);
// if (l.itemID == liquid.itemID && l.itemMeta ==
// liquid.itemMeta)
if (l.isFluidEqual(liquid))
{
l.amount += liquid.amount;
added = true;
}
if (l.amount <= 0)
{
moltenMetal.remove(l);
i--;
}
}
if (!added)
{
if (first)
moltenMetal.add(0, liquid.copy());
else
moltenMetal.add(liquid.copy());
}
return true;
}
}
private void updateTemperatures ()
{
inUse = true;
for (int i = 0; i < maxBlockCapacity; i++)
{
meltingTemps[i] = Smeltery.getLiquifyTemperature(inventory[i]) * 10; // temperatures are *10 for more progress control
}
}
public void updateFuelDisplay ()
{
if (activeLavaTank == null)
return;
if (!worldObj.blockExists(activeLavaTank.x, activeLavaTank.y, activeLavaTank.z))
{
fuelAmount = 0;
fuelGague = 0;
return;
}
TileEntity tankContainer = worldObj.getTileEntity(activeLavaTank.x, activeLavaTank.y, activeLavaTank.z);
if (tankContainer == null)
{
fuelAmount = 0;
fuelGague = 0;
return;
}
if (tankContainer instanceof IFluidHandler)
{
FluidStack liquid = ((IFluidHandler) tankContainer).drain(ForgeDirection.DOWN, 4000, false);
if (liquid != null && Smeltery.isSmelteryFuel(liquid.getFluid()))
{
FluidTankInfo[] info = ((IFluidHandler) tankContainer).getTankInfo(ForgeDirection.DOWN);
if (info.length > 0)
{
int capacity = info[0].capacity;
fuelAmount = liquid.amount;
fuelGague = liquid.amount * 52 / capacity;
}
}
else
{
fuelAmount = 0;
fuelGague = 0;
}
}
}
public void updateFuelGague ()
{
if (activeLavaTank == null || useTime > 0)
return;
if (!worldObj.blockExists(activeLavaTank.x, activeLavaTank.y, activeLavaTank.z))
{
fuelAmount = 0;
fuelGague = 0;
return;
}
TileEntity tankContainer = worldObj.getTileEntity(activeLavaTank.x, activeLavaTank.y, activeLavaTank.z);
if (tankContainer == null)
{
fuelAmount = 0;
fuelGague = 0;
return;
}
if (tankContainer instanceof IFluidHandler)
{
needsUpdate = true;
FluidStack liquid = ((IFluidHandler) tankContainer).drain(ForgeDirection.DOWN, 15, false);
if (liquid != null && Smeltery.isSmelteryFuel(liquid.getFluid()))
{
liquid = ((IFluidHandler) tankContainer).drain(ForgeDirection.DOWN, 15, true);
useTime += Smeltery.getFuelDuration(liquid.getFluid());
internalTemp = Smeltery.getFuelPower(liquid.getFluid());
FluidTankInfo[] info = ((IFluidHandler) tankContainer).getTankInfo(ForgeDirection.DOWN);
liquid = info[0].fluid;
int capacity = info[0].capacity;
if (liquid != null)
{
fuelAmount = liquid.amount;
fuelGague = liquid.amount * 52 / capacity;
}
else
{
fuelAmount = 0;
fuelGague = 0;
}
}
else
{
boolean foundTank = false;
int iter = 0;
while (!foundTank)
{
CoordTuple possibleTank = lavaTanks.get(iter);
TileEntity newTankContainer = worldObj.getTileEntity(possibleTank.x, possibleTank.y, possibleTank.z);
if (newTankContainer instanceof IFluidHandler)
{
// TConstruct.logger.info("Tank: "+possibleTank.toString());
FluidStack newliquid = ((IFluidHandler) newTankContainer).drain(ForgeDirection.UNKNOWN, 150, false);
if (newliquid != null && Smeltery.isSmelteryFuel(newliquid.getFluid()) && newliquid.amount > 0)
{
// TConstruct.logger.info("Tank: "+possibleTank.toString());
foundTank = true;
activeLavaTank = possibleTank;
iter = lavaTanks.size();
/*
* IFluidTank newTank = ((IFluidHandler)
* newTankContainer).getTank(ForgeDirection.UNKNOWN,
* liquid); liquid = newTank.getFluid(); int
* capacity = newTank.getCapacity();
*/
FluidTankInfo[] info = ((IFluidHandler) tankContainer).getTankInfo(ForgeDirection.DOWN);
liquid = info[0].fluid;
int capacity = info[0].capacity;
if (liquid != null)
{
fuelAmount = liquid.amount;
fuelGague = liquid.amount * 52 / capacity;
}
else
{
fuelAmount = 0;
fuelGague = 0;
}
}
}
iter++;
if (iter >= lavaTanks.size())
foundTank = true;
}
// TConstruct.logger.info("Searching for tank, size: "+lavaTanks.size());
}
}
}
@SideOnly(Side.CLIENT)
public IIcon getFuelIcon ()
{
IIcon defaultLava = Blocks.lava.getIcon(0, 0);
if (activeLavaTank == null)
return defaultLava;
TileEntity tankContainer = worldObj.getTileEntity(activeLavaTank.x, activeLavaTank.y, activeLavaTank.z);
if (tankContainer instanceof IFluidHandler)
return ((IFluidHandler) tankContainer).getTankInfo(ForgeDirection.DOWN)[0].fluid.getFluid().getStillIcon();
return defaultLava;
}
public FluidStack getResultFor (ItemStack stack)
{
return Smeltery.getSmelteryResult(stack);
}
/* Inventory */
/*
* public int getMaxStackStackSize (ItemStack stack) { FluidStack liquid =
* getResultFor(stack); if (liquid == null) return 0; return liquid.amount;
* }
*/
@Override
public int getInventoryStackLimit ()
{
return 1;
}
@Override
public void markDirty ()
{
updateTemperatures();
updateEntity();
super.markDirty();
needsUpdate = true;
// worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
// worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord);
}
/*
* @Override public void setInventorySlotContents (int slot, ItemStack
* itemstack) { inventory[slot] = itemstack != null ?
* itemstack.splitStack(1) : null; //May include unintended side effects.
* Possible fix for max stack size of 1? }
*/
/* Multiblock */
@Override
public void notifyChange (IServantLogic servant, int x, int y, int z)
{
checkValidPlacement();
}
public void checkValidPlacement ()
{
switch (getRenderDirection())
{
case 2: // +z
alignInitialPlacement(xCoord, yCoord, zCoord + 1);
break;
case 3: // -z
alignInitialPlacement(xCoord, yCoord, zCoord - 1);
break;
case 4: // +x
alignInitialPlacement(xCoord + 1, yCoord, zCoord);
break;
case 5: // -x
alignInitialPlacement(xCoord - 1, yCoord, zCoord);
break;
}
}
// aligns the position given (inside the smeltery) to be the center of the smeltery
public void alignInitialPlacement (int x, int y, int z)
{
// x/y/z = the block behind the controller "inside the smeltery"
// adjust the x-position of the block until the difference between the outer walls is at most 1
// basically this means we center the block inside the smeltery on the x axis.
int xd1 = 1, xd2 = 1; // x-difference
for(int i = 1; i < MAX_SMELTERY_SIZE; i++) // don't check farther than needed
{
if(worldObj.getBlock(x - xd1, y, z) == null || worldObj.isAirBlock(x - xd1,y,z))
xd1++;
else if(worldObj.getBlock(x + xd2, y, z) == null || worldObj.isAirBlock(x + xd2,y,z))
xd2++;
// if one side hit a wall and the other didn't we might have to center our x-position again
if(xd1-xd2 > 1)
{
// move x and offsets to the -x
xd1--;
x--;
xd2++;
}
// or the right
if(xd2-xd1 > 1)
{
xd2--;
x++;
xd1++;
}
}
// same for z-axis
int zd1 = 1, zd2 = 1;
for(int i = 1; i < MAX_SMELTERY_SIZE; i++) // don't check farther than needed
{
if(worldObj.getBlock(x, y, z - zd1) == null || worldObj.isAirBlock(x, y, z - zd1))
zd1++;
else if(worldObj.getBlock(x, y, z + zd2) == null || worldObj.isAirBlock(x, y, z + zd2))
zd2++;
// if one side hit a wall and the other didn't we might have to center our x-position again
if(zd1-zd2 > 1)
{
// move x and offsets to the -x
zd1--;
z--;
zd2++;
}
// or the right
if(zd2-zd1 > 1)
{
zd2--;
z++;
zd1++;
}
}
// do the check
int[] sides = new int[] {xd1, xd2, zd1, zd2};
checkValidStructure(x, y, z, sides);
}
/**
*
* @param x x-center of the smeltery +-1
* @param y y-position of the controller block
* @param z z-center of the smeltery +-1
* @param sides distance between the center point and the wall. [-x,+x,-z,+z]
*/
public void checkValidStructure (int x, int y, int z, int[] sides)
{
int checkLayers = 0;
//worldObj.setBlock(x,y,z, Blocks.redstone_block);
//worldObj.setBlock(x+sides[1]-sides[0],y+1,z+sides[3]-sides[2], Blocks.lapis_block);
tempValidStructure = false;
// this piece of code here does the complete validity check.
if (checkSameLevel(x, y, z, sides))
{
checkLayers++;
checkLayers += recurseStructureUp(x, y + 1, z, sides, 0);
checkLayers += recurseStructureDown(x, y - 1, z, sides, 0);
}
// maxLiquid = capacity * 20000;
if (tempValidStructure != validStructure || checkLayers != this.layers)
{
if (tempValidStructure)
{
// try to derive temperature from fueltank
activeLavaTank = null;
for (CoordTuple tank : lavaTanks)
{
TileEntity tankContainer = worldObj.getTileEntity(tank.x, tank.y, tank.z);
if (!(tankContainer instanceof IFluidHandler))
continue;
FluidStack liquid = ((IFluidHandler) tankContainer).getTankInfo(ForgeDirection.DOWN)[0].fluid;
if (liquid == null)
continue;
if (!Smeltery.isSmelteryFuel(liquid.getFluid()))
continue;
internalTemp = Smeltery.getFuelPower(liquid.getFluid());
activeLavaTank = tank;
break;
}
// no tank with fuel. we reserve the first found one
if (activeLavaTank == null)
activeLavaTank = lavaTanks.get(0);
// update other stuff
adjustLayers(checkLayers, false);
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
validStructure = true;
}
else
{
internalTemp = 20;
validStructure = false;
}
}
}
public boolean checkBricksOnLevel(int x, int y, int z, int[] sides)
{
int numBricks = 0;
Block block;
int xMin = x - sides[0];
int xMax = x + sides[1];
int zMin = z - sides[2];
int zMax = z + sides[3];
// Check inside
for (int xPos = xMin + 1; xPos <= xMax - 1; xPos++)
{
for (int zPos = zMin + 1; zPos <= zMax - 1; zPos++)
{
block = worldObj.getBlock(xPos, y, zPos);
if (block != null && !worldObj.isAirBlock(xPos, y, zPos))
return false;
}
}
// Check outer layer
for (int xPos = xMin + 1; xPos <= xMax - 1; xPos++)
{
numBricks += checkBricks(xPos, y, zMin);
numBricks += checkBricks(xPos, y, zMax);
}
for (int zPos = zMin + 1; zPos <= zMax - 1; zPos++)
{
numBricks += checkBricks(xMin, y, zPos);
numBricks += checkBricks(xMax, y, zPos);
}
int neededBricks = (xMax-xMin)*2 + (zMax-zMin)*2 - 4; // -4 because corners are not needed
return numBricks == neededBricks;
}
public boolean checkSameLevel(int x, int y, int z, int[] sides)
{
lavaTanks.clear();
boolean check = checkBricksOnLevel(x,y,z,sides);
if (check && lavaTanks.size() > 0)
return true;
else
return false;
}
public int recurseStructureUp (int x, int y, int z, int[] sides, int count)
{
boolean check = checkBricksOnLevel(x,y,z,sides);
if(!check)
return count;
count++;
return recurseStructureUp(x, y + 1, z, sides, count);
}
public int recurseStructureDown (int x, int y, int z, int[] sides, int count)
{
boolean check = checkBricksOnLevel(x,y,z,sides);
if(!check) {
// regular check failed, maybe it's the bottom?
Block block = worldObj.getBlock(x,y,z);
if (block != null && !worldObj.isAirBlock(x, y, z))
if (validBlockID(block))
return validateBottom(x, y, z, sides, count);
return count;
}
count++;
return recurseStructureDown(x, y - 1, z, sides, count);
}
public int validateBottom (int x, int y, int z, int[] sides, int count)
{
int bottomBricks = 0;
int xMin = x - sides[0] + 1;
int xMax = x + sides[1] - 1;
int zMin = z - sides[2] + 1;
int zMax = z + sides[3] - 1;
// Check inside
for (int xPos = xMin; xPos <= xMax; xPos++)
{
for (int zPos = zMin; zPos <= zMax; zPos++)
{
if (validBlockID(worldObj.getBlock(xPos, y, zPos)) && (worldObj.getBlockMetadata(xPos, y, zPos) >= 2))
bottomBricks++;
}
}
int neededBricks = (xMax+1-xMin) * (zMax+1-zMin); // +1 because we want inclusive the upper border
if (bottomBricks == neededBricks)
{
tempValidStructure = true;
minPos = new CoordTuple(xMin, y+1, zMin);
maxPos = new CoordTuple(xMax, y+1, zMax);
}
return count;
}
/*
* Returns whether the brick is a lava tank or not. Increments bricks, sets
* them as part of the structure, and adds tanks to the list.
*/
int checkBricks (int x, int y, int z)
{
int tempBricks = 0;
Block blockID = worldObj.getBlock(x, y, z);
if (validBlockID(blockID) || validTankID(blockID))
{
TileEntity te = worldObj.getTileEntity(x, y, z);
if (te == this)
{
tempBricks++;
}
else if (te instanceof MultiServantLogic)
{
MultiServantLogic servant = (MultiServantLogic) te;
if (servant.hasValidMaster())
{
if (servant.verifyMaster(this, worldObj, this.xCoord, this.yCoord, this.zCoord))
tempBricks++;
}
else
{
servant.overrideMaster(this.xCoord, this.yCoord, this.zCoord);
tempBricks++;
}
if (te instanceof LavaTankLogic)
{
lavaTanks.add(new CoordTuple(x, y, z));
}
}
}
return tempBricks;
}
boolean validBlockID (Block blockID)
{
return blockID == TinkerSmeltery.smeltery || blockID == TinkerSmeltery.smelteryNether;
}
boolean validTankID (Block blockID)
{
return blockID == TinkerSmeltery.lavaTank || blockID == TinkerSmeltery.lavaTankNether;
}
@Override
public int getCapacity ()
{
return maxLiquid;
}
public int getTotalLiquid ()
{
return currentLiquid;
}
@Override
public FluidStack drain (int maxDrain, boolean doDrain)
{
if (moltenMetal.size() == 0)
return null;
FluidStack liquid = moltenMetal.get(0);
if (liquid != null)
{
if (liquid.amount - maxDrain <= 0)
{
FluidStack liq = liquid.copy();
if (doDrain)
{
// liquid = null;
moltenMetal.remove(liquid);
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
currentLiquid = 0;
needsUpdate = true;
}
return liq;
}
else
{
if (doDrain && maxDrain > 0)
{
liquid.amount -= maxDrain;
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
currentLiquid -= maxDrain;
needsUpdate = true;
}
return new FluidStack(liquid.fluidID, maxDrain, liquid.tag);
}
}
else
{
return new FluidStack(0, 0);
}
}
@Override
public int fill (FluidStack resource, boolean doFill)
{
if (resource != null && currentLiquid < maxLiquid)// resource.amount +
// currentLiquid <
// maxLiquid)
{
if (resource.amount + currentLiquid > maxLiquid)
resource.amount = maxLiquid - currentLiquid;
int amount = resource.amount;
if (amount > 0 && doFill)
{
if (addMoltenMetal(resource, false))
{
ArrayList alloys = Smeltery.mixMetals(moltenMetal);
for (int al = 0; al < alloys.size(); al++)
{
FluidStack liquid = (FluidStack) alloys.get(al);
addMoltenMetal(liquid, true);
}
}
needsUpdate = true;
worldObj.func_147479_m(xCoord, yCoord, zCoord);
}
return amount;
}
else
return 0;
}
@Override
public FluidStack getFluid ()
{
if (moltenMetal.size() == 0)
return null;
return moltenMetal.get(0);
}
@Override
public int getFluidAmount ()
{
return currentLiquid;
}
@Override
public FluidTankInfo getInfo ()
{
return new FluidTankInfo(this);
}
public FluidTankInfo[] getMultiTankInfo ()
{
FluidTankInfo[] info = new FluidTankInfo[moltenMetal.size() + 1];
for (int i = 0; i < moltenMetal.size(); i++)
{
FluidStack fluid = moltenMetal.get(i);
info[i] = new FluidTankInfo(fluid.copy(), fluid.amount);
}
info[moltenMetal.size()] = new FluidTankInfo(null, maxLiquid - currentLiquid);
return info;
}
/* NBT */
@Override
public void readFromNBT (NBTTagCompound tags)
{
layers = tags.getInteger("Layers");
int[] pos = tags.getIntArray("MinPos");
if (pos.length > 2)
minPos = new CoordTuple(pos[0], pos[1], pos[2]);
else
minPos = new CoordTuple(xCoord, yCoord, zCoord);
pos = tags.getIntArray("MaxPos");
if (pos.length > 2)
maxPos = new CoordTuple(pos[0], pos[1], pos[2]);
else
maxPos = new CoordTuple(xCoord, yCoord, zCoord);
maxBlockCapacity = getBlocksPerLayer() * layers;
inventory = new ItemStack[maxBlockCapacity];
super.readFromNBT(tags);
// validStructure = tags.getBoolean("ValidStructure");
internalTemp = tags.getInteger("InternalTemp");
inUse = tags.getBoolean("InUse");
direction = tags.getByte("Direction");
useTime = tags.getInteger("UseTime");
currentLiquid = tags.getInteger("CurrentLiquid");
maxLiquid = tags.getInteger("MaxLiquid");
meltingTemps = tags.getIntArray("MeltingTemps");
activeTemps = tags.getIntArray("ActiveTemps");
NBTTagList liquidTag = tags.getTagList("Liquids", 10);
moltenMetal.clear();
for (int iter = 0; iter < liquidTag.tagCount(); iter++)
{
NBTTagCompound nbt = (NBTTagCompound) liquidTag.getCompoundTagAt(iter);
FluidStack fluid = FluidStack.loadFluidStackFromNBT(nbt);
if (fluid != null)
moltenMetal.add(fluid);
}
// adjustLayers(layers, true);
// checkValidPlacement();
}
@Override
public void writeToNBT (NBTTagCompound tags)
{
super.writeToNBT(tags);
// tags.setBoolean("ValidStructure", validStructure);
tags.setInteger("InternalTemp", internalTemp);
tags.setBoolean("InUse", inUse);
int[] pos;
if (minPos == null)
pos = new int[] { xCoord, yCoord, zCoord };
else
pos = new int[] { minPos.x, minPos.y, minPos.z };
tags.setIntArray("MinPos", pos);
if (maxPos == null)
pos = new int[] { xCoord, yCoord, zCoord };
else
pos = new int[] { maxPos.x, maxPos.y, maxPos.z };
tags.setIntArray("MaxPos", pos);
tags.setByte("Direction", direction);
tags.setInteger("UseTime", useTime);
tags.setInteger("CurrentLiquid", currentLiquid);
tags.setInteger("MaxLiquid", maxLiquid);
tags.setInteger("Layers", layers);
tags.setIntArray("MeltingTemps", meltingTemps);
tags.setIntArray("ActiveTemps", activeTemps);
NBTTagList taglist = new NBTTagList();
for (FluidStack liquid : moltenMetal)
{
NBTTagCompound nbt = new NBTTagCompound();
liquid.writeToNBT(nbt);
taglist.appendTag(nbt);
}
tags.setTag("Liquids", taglist);
}
/* Packets */
@Override
public Packet getDescriptionPacket ()
{
NBTTagCompound tag = new NBTTagCompound();
writeToNBT(tag);
return new S35PacketUpdateTileEntity(xCoord, yCoord, zCoord, 1, tag);
}
@Override
public void onDataPacket (NetworkManager net, S35PacketUpdateTileEntity packet)
{
readFromNBT(packet.func_148857_g());
markDirty();
worldObj.func_147479_m(xCoord, yCoord, zCoord);
this.needsUpdate = true;
}
@Override
public String getInventoryName ()
{
return getDefaultName();
}
@Override
public boolean hasCustomInventoryName ()
{
return true;
}
@Override
public void closeInventory ()
{
}
@Override
public void openInventory ()
{
}
}