400 lines
8.9 KiB
Java
400 lines
8.9 KiB
Java
package tinker.tconstruct.logic;
|
|
|
|
import net.minecraft.block.Block;
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
import net.minecraft.item.ItemFood;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.network.INetworkManager;
|
|
import net.minecraft.network.packet.Packet;
|
|
import net.minecraft.network.packet.Packet132TileEntityData;
|
|
import net.minecraft.tileentity.TileEntity;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.liquids.ILiquidTank;
|
|
import net.minecraftforge.liquids.LiquidStack;
|
|
import tinker.common.IActiveLogic;
|
|
import tinker.common.IFacingLogic;
|
|
import tinker.common.InventoryLogic;
|
|
import tinker.tconstruct.TConstructContent;
|
|
import tinker.tconstruct.client.gui.SmelteryContainer;
|
|
import tinker.tconstruct.crafting.Smeltery;
|
|
|
|
/* Simple class for storing items in the block
|
|
*/
|
|
|
|
public class SmelteryLogic extends InventoryLogic
|
|
implements IActiveLogic, IFacingLogic
|
|
{
|
|
boolean validStructure;
|
|
byte direction;
|
|
int internalTemp;
|
|
int maxTemp;
|
|
int useTime;
|
|
public int fuelGague;
|
|
int[] tankCoords;
|
|
int[] bottomTemps;
|
|
int tick;
|
|
|
|
public SmelteryLogic()
|
|
{
|
|
super(9);
|
|
bottomTemps = new int[9];
|
|
for (int i = 0; i < 9; i++)
|
|
bottomTemps[i] = 20;
|
|
}
|
|
|
|
/* Misc */
|
|
@Override
|
|
public String getInvName ()
|
|
{
|
|
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 getDirection()
|
|
{
|
|
return direction;
|
|
}
|
|
|
|
@Override
|
|
public void setDirection(byte dir)
|
|
{
|
|
direction = dir;
|
|
}
|
|
|
|
@Override
|
|
public boolean getActive()
|
|
{
|
|
return validStructure;
|
|
}
|
|
|
|
@Override
|
|
public void setActive(boolean flag)
|
|
{
|
|
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
|
|
}
|
|
|
|
@Override
|
|
public boolean canFaceVertical()
|
|
{
|
|
return false;
|
|
}
|
|
|
|
public int getScaledFuelGague (int scale)
|
|
{
|
|
return (fuelGague * scale) / 52;
|
|
}
|
|
|
|
public int getInternalTemperature ()
|
|
{
|
|
return internalTemp;
|
|
}
|
|
|
|
public int getTempForSlot (int slot)
|
|
{
|
|
return bottomTemps[slot];
|
|
}
|
|
|
|
/* Updating */
|
|
public void updateEntity ()
|
|
{
|
|
tick++;
|
|
if (tick % 4 == 0)
|
|
updateTemperatures();
|
|
|
|
if (tick == 20)
|
|
{
|
|
tick = 0;
|
|
checkValidPlacement();
|
|
updateFuelGague();
|
|
|
|
if (useTime > 0)
|
|
useTime--;
|
|
if (!worldObj.isRemote)
|
|
matchInventoryToWorld();
|
|
|
|
if (validStructure && useTime == 0)
|
|
{
|
|
TileEntity tank = worldObj.getBlockTileEntity(tankCoords[0], tankCoords[1], tankCoords[2]);
|
|
if (tank instanceof ILiquidTank)
|
|
{
|
|
LiquidStack liquid = ((ILiquidTank)tank).drain(10, true);
|
|
if (liquid != null)
|
|
{
|
|
System.out.println("Drained "+liquid.amount);
|
|
useTime += liquid.amount;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void updateTemperatures()
|
|
{
|
|
for (int i = 0; i < 9; i++)
|
|
{
|
|
if (this.isStackInSlot(i) && bottomTemps[i] < internalTemp)
|
|
bottomTemps[i] += 1;
|
|
else
|
|
bottomTemps[i] = 20;
|
|
}
|
|
}
|
|
|
|
void updateFuelGague()
|
|
{
|
|
if (tankCoords == null || tankCoords.length < 3)
|
|
return;
|
|
|
|
TileEntity tank = worldObj.getBlockTileEntity(tankCoords[0], tankCoords[1], tankCoords[2]);
|
|
if (tank == null)
|
|
{
|
|
fuelGague = 0;
|
|
}
|
|
if (tank instanceof ILiquidTank)
|
|
{
|
|
LiquidStack liquid = ((ILiquidTank)tank).getLiquid();
|
|
int capacity = ((ILiquidTank)tank).getCapacity();
|
|
if (liquid != null)
|
|
fuelGague = liquid.amount * 52 / capacity;
|
|
else
|
|
fuelGague = 0;
|
|
}
|
|
}
|
|
|
|
public ItemStack getResultFor (ItemStack stack)
|
|
{
|
|
ItemStack result = Smeltery.instance.getSmeltingResult(stack);
|
|
if (result != null)
|
|
return result;
|
|
|
|
return null;
|
|
}
|
|
|
|
/* Inventory */
|
|
public int getInventoryStackLimit ()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents(int slot, ItemStack itemstack)
|
|
{
|
|
super.setInventorySlotContents(slot, itemstack);
|
|
setWorldToInventory();
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize(int slot, int quantity)
|
|
{
|
|
ItemStack stack = super.decrStackSize(slot, quantity);
|
|
setWorldToInventory();
|
|
return stack;
|
|
}
|
|
|
|
/* World-inventory matching */
|
|
void matchInventoryToWorld()
|
|
{
|
|
switch(getDirection())
|
|
{
|
|
case 2: // +z
|
|
grabWorldBlocks(xCoord, yCoord, zCoord+2);
|
|
break;
|
|
case 3: // -z
|
|
grabWorldBlocks(xCoord, yCoord, zCoord-2);
|
|
break;
|
|
case 4: // +x
|
|
grabWorldBlocks(xCoord+2, yCoord, zCoord);
|
|
break;
|
|
case 5: // -x
|
|
grabWorldBlocks(xCoord-2, yCoord, zCoord);
|
|
break;
|
|
}
|
|
}
|
|
|
|
void setWorldToInventory()
|
|
{
|
|
switch(getDirection())
|
|
{
|
|
case 2: // +z
|
|
setWorldToInventory(xCoord, yCoord, zCoord+2);
|
|
break;
|
|
case 3: // -z
|
|
setWorldToInventory(xCoord, yCoord, zCoord-2);
|
|
break;
|
|
case 4: // +x
|
|
setWorldToInventory(xCoord+2, yCoord, zCoord);
|
|
break;
|
|
case 5: // -x
|
|
setWorldToInventory(xCoord-2, yCoord, zCoord);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void grabWorldBlocks(int x, int y, int z)
|
|
{
|
|
for (int xPos = 0; xPos <= 2; xPos++)
|
|
{
|
|
for (int zPos = 0; zPos <= 2; zPos++)
|
|
{
|
|
int bID = worldObj.getBlockId(xPos+x-1, y, zPos+z-1);
|
|
|
|
ItemStack stack = inventory[xPos+zPos*3];
|
|
if (bID == 0)
|
|
inventory[xPos+zPos*3] = null;
|
|
else if (stack == null || stack.itemID != bID)
|
|
inventory[xPos+zPos*3] = new ItemStack(bID, 1, worldObj.getBlockMetadata(xPos+x-1, y, zPos+z-1));
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setWorldToInventory(int x, int y, int z)
|
|
{
|
|
for (int xPos = 0; xPos <= 2; xPos++)
|
|
{
|
|
for (int zPos = 0; zPos <= 2; zPos++)
|
|
{
|
|
ItemStack stack = inventory[xPos+zPos*3];
|
|
if (stack == null)
|
|
worldObj.setBlockWithNotify(xPos+x-1, y, zPos+z-1, 0);
|
|
|
|
else if (stack.itemID < Block.blocksList.length && Block.blocksList[stack.itemID] != null)
|
|
worldObj.setBlockAndMetadataWithNotify(xPos+x-1, y, zPos+z-1, stack.itemID, stack.getItemDamage());
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkValidPlacement()
|
|
{
|
|
switch(getDirection())
|
|
{
|
|
case 2: // +z
|
|
checkValidStructure(xCoord, yCoord, zCoord+2);
|
|
break;
|
|
case 3: // -z
|
|
checkValidStructure(xCoord, yCoord, zCoord-2);
|
|
break;
|
|
case 4: // +x
|
|
checkValidStructure(xCoord+2, yCoord, zCoord);
|
|
break;
|
|
case 5: // -x
|
|
checkValidStructure(xCoord-2, yCoord, zCoord);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void checkValidStructure(int x, int y, int z)
|
|
{
|
|
int numBricks = 0;
|
|
boolean lavaTank = false;
|
|
|
|
//Check outer layer
|
|
for (int xPos = x-1; xPos <= x+1; xPos++)
|
|
{
|
|
int southID = worldObj.getBlockId(xPos, y, z-2);
|
|
int northID = worldObj.getBlockId(xPos, y, z+2);
|
|
if (southID == TConstructContent.searedBrick.blockID)
|
|
numBricks++;
|
|
else if (southID == TConstructContent.lavaTank.blockID)
|
|
{
|
|
tankCoords = new int[] {xPos, y, z-2};
|
|
lavaTank = true;
|
|
}
|
|
|
|
if (northID == TConstructContent.searedBrick.blockID)
|
|
numBricks++;
|
|
else if (northID == TConstructContent.lavaTank.blockID)
|
|
{
|
|
tankCoords = new int[] {xPos, y, z+2};
|
|
lavaTank = true;
|
|
}
|
|
}
|
|
for (int zPos = z-1; zPos <= z+1; zPos++)
|
|
{
|
|
int westID = worldObj.getBlockId(x-2, y, zPos);
|
|
int eastID = worldObj.getBlockId(x+2, y, zPos);
|
|
if (westID == TConstructContent.searedBrick.blockID)
|
|
numBricks++;
|
|
else if (westID == TConstructContent.lavaTank.blockID)
|
|
{
|
|
tankCoords = new int[] {x-2, y, zPos};
|
|
lavaTank = true;
|
|
}
|
|
|
|
if (eastID == TConstructContent.searedBrick.blockID)
|
|
numBricks++;
|
|
else if (eastID == TConstructContent.lavaTank.blockID)
|
|
{
|
|
tankCoords = new int[] {x+2, y, zPos};
|
|
lavaTank = true;
|
|
}
|
|
}
|
|
|
|
//Check floor
|
|
for (int xPos = x-1; xPos <= x+1; xPos++)
|
|
{
|
|
for (int zPos = z-1; zPos <= z+1; zPos++)
|
|
{
|
|
if (worldObj.getBlockId(xPos, y-1, zPos) == TConstructContent.searedBrick.blockID)
|
|
numBricks++;
|
|
}
|
|
}
|
|
|
|
if (numBricks == 19 && lavaTank)
|
|
{
|
|
validStructure = true;
|
|
internalTemp = 550;
|
|
}
|
|
else
|
|
{
|
|
validStructure = false;
|
|
internalTemp = 20;
|
|
}
|
|
}
|
|
|
|
/* NBT */
|
|
@Override
|
|
public void readFromNBT(NBTTagCompound tags)
|
|
{
|
|
super.readFromNBT(tags);
|
|
validStructure = tags.getBoolean("ValidStructure");
|
|
direction = tags.getByte("Direction");
|
|
useTime = tags.getInteger("UseTime");
|
|
internalTemp = tags.getInteger("Temp");
|
|
tankCoords = tags.getIntArray("TankCoords");
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT(NBTTagCompound tags)
|
|
{
|
|
super.writeToNBT(tags);
|
|
tags.setBoolean("ValidStructure", validStructure);
|
|
tags.setByte("Direction", direction);
|
|
tags.setInteger("UseTime", useTime);
|
|
tags.setInteger("Temp", internalTemp);
|
|
tags.setIntArray("TankCoords", tankCoords);
|
|
}
|
|
|
|
/* Packets */
|
|
@Override
|
|
public Packet getDescriptionPacket ()
|
|
{
|
|
NBTTagCompound tag = new NBTTagCompound();
|
|
writeToNBT(tag);
|
|
return new Packet132TileEntityData(xCoord, yCoord, zCoord, 1, tag);
|
|
}
|
|
|
|
@Override
|
|
public void onDataPacket (INetworkManager net, Packet132TileEntityData packet)
|
|
{
|
|
worldObj.getBlockTileEntity(xCoord, yCoord, zCoord).readFromNBT(packet.customParam1);
|
|
worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord);
|
|
}
|
|
}
|