mirror of
https://github.com/GTNewHorizons/TinkersConstruct.git
synced 2026-11-19 11:59:14 +00:00
588 lines
16 KiB
Java
588 lines
16 KiB
Java
package tconstruct.blocks.logic;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.HashMap;
|
|
import java.util.Iterator;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.player.InventoryPlayer;
|
|
import net.minecraft.inventory.Container;
|
|
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.util.MathHelper;
|
|
import net.minecraft.world.World;
|
|
import net.minecraftforge.common.ForgeDirection;
|
|
import net.minecraftforge.fluids.Fluid;
|
|
import net.minecraftforge.fluids.FluidStack;
|
|
import net.minecraftforge.fluids.FluidTankInfo;
|
|
import net.minecraftforge.fluids.IFluidHandler;
|
|
import tconstruct.TConstruct;
|
|
import tconstruct.blocks.component.SmelteryComponent;
|
|
import tconstruct.blocks.component.SmelteryScan;
|
|
import tconstruct.common.TContent;
|
|
import tconstruct.common.TRepo;
|
|
import tconstruct.inventory.AdaptiveSmelteryContainer;
|
|
import mantle.blocks.abstracts.AdaptiveInventoryLogic;
|
|
import tconstruct.library.component.IComponentHolder;
|
|
import tconstruct.library.component.LogicComponent;
|
|
import tconstruct.library.component.MultiFluidTank;
|
|
import mantle.blocks.iface.IActiveLogic;
|
|
import mantle.world.CoordTuple;
|
|
import mantle.blocks.iface.IMasterLogic;
|
|
import mantle.blocks.iface.IServantLogic;
|
|
|
|
public class AdaptiveSmelteryLogic extends AdaptiveInventoryLogic implements IActiveLogic, IMasterLogic, IComponentHolder, IFluidHandler
|
|
{
|
|
byte direction;
|
|
boolean updateFluids = false;
|
|
boolean recheckStructure = false;
|
|
boolean updateAir = false;
|
|
SmelteryScan structure = new SmelteryScan(this, TRepo.smeltery, TRepo.lavaTank);
|
|
MultiFluidTank multitank = new MultiFluidTank();
|
|
SmelteryComponent smeltery = new SmelteryComponent(this, structure, multitank, 800);
|
|
HashMap<CoordTuple, LiquidDataInstance> airUpdates = new HashMap<CoordTuple, LiquidDataInstance>();
|
|
int tick = 0;
|
|
|
|
public MultiFluidTank getMultiTank ()
|
|
{
|
|
return multitank;
|
|
}
|
|
|
|
public SmelteryComponent getSmeltery ()
|
|
{
|
|
return smeltery;
|
|
}
|
|
|
|
public void updateEntity ()
|
|
{
|
|
tick++;
|
|
if (tick % 4 == 0)
|
|
smeltery.heatItems();
|
|
|
|
if (!worldObj.isRemote)
|
|
{
|
|
if (tick % 20 == 0)
|
|
{
|
|
if (structure.isComplete())
|
|
smeltery.update();
|
|
|
|
if (updateFluids)
|
|
{
|
|
distributeFluids();
|
|
updateFluids = false;
|
|
}
|
|
|
|
if (updateAir)
|
|
{
|
|
updateAir();
|
|
updateAir = false;
|
|
}
|
|
|
|
if (recheckStructure)
|
|
{
|
|
structure.recheckStructure();
|
|
recheckStructure = false;
|
|
}
|
|
}
|
|
|
|
if (tick >= 60)
|
|
{
|
|
if (!structure.isComplete())
|
|
{
|
|
structure.checkValidStructure();
|
|
if (structure.isComplete())
|
|
{
|
|
validateSmeltery();
|
|
}
|
|
}
|
|
tick = 0;
|
|
}
|
|
|
|
if (airUpdates.size() > 0)
|
|
updateFluidBlocks();
|
|
}
|
|
}
|
|
|
|
public void setUpdateFluids ()
|
|
{
|
|
updateFluids = true;
|
|
}
|
|
|
|
@Override
|
|
public List<LogicComponent> getComponents ()
|
|
{
|
|
ArrayList<LogicComponent> ret = new ArrayList<LogicComponent>(3);
|
|
ret.add(structure);
|
|
ret.add(multitank);
|
|
ret.add(smeltery);
|
|
return ret;
|
|
}
|
|
|
|
/* Structure */
|
|
|
|
@Override
|
|
public void setWorldObj (World world)
|
|
{
|
|
super.setWorldObj(world);
|
|
structure.setWorld(world);
|
|
smeltery.setWorld(world);
|
|
}
|
|
|
|
@Override
|
|
public void notifyChange (IServantLogic servant, int x, int y, int z)
|
|
{
|
|
if (!worldObj.isRemote)
|
|
{
|
|
//System.out.println("Notifying of change from "+new CoordTuple(x, y, z));
|
|
recheckStructure = true;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void placeBlock (EntityLivingBase entity, ItemStack itemstack)
|
|
{
|
|
structure.checkValidStructure();
|
|
if (structure.isComplete())
|
|
{
|
|
validateSmeltery();
|
|
}
|
|
}
|
|
|
|
void validateSmeltery ()
|
|
{
|
|
adjustInventory(structure.getAirSize(), true);
|
|
smeltery.adjustSize(structure.getAirSize(), true);
|
|
multitank.setCapacity(structure.getAirSize() * (TConstruct.ingotLiquidValue * 18));
|
|
smeltery.setActiveLavaTank(structure.lavaTanks.get(0));
|
|
worldObj.markBlockForUpdate(xCoord, yCoord, zCoord);
|
|
}
|
|
|
|
@Override
|
|
public void removeBlock ()
|
|
{
|
|
structure.cleanup();
|
|
}
|
|
|
|
/* Direction */
|
|
|
|
@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 structure.isComplete();
|
|
}
|
|
|
|
@Override
|
|
public void setActive (boolean flag)
|
|
{
|
|
|
|
}
|
|
|
|
/* Inventory */
|
|
|
|
@Override
|
|
public int getInventoryStackLimit ()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
@Override
|
|
public void setInventorySlotContents (int slot, ItemStack itemstack)
|
|
{
|
|
inventory[slot] = itemstack;
|
|
if (itemstack != null && itemstack.stackSize > getInventoryStackLimit())
|
|
{
|
|
itemstack.stackSize = getInventoryStackLimit();
|
|
}
|
|
updateWorldBlock(slot, itemstack);
|
|
updateAir = true;
|
|
}
|
|
|
|
@Override
|
|
public ItemStack decrStackSize (int slot, int quantity)
|
|
{
|
|
if (inventory[slot] != null)
|
|
{
|
|
if (inventory[slot].stackSize <= quantity)
|
|
{
|
|
ItemStack stack = inventory[slot];
|
|
inventory[slot] = null;
|
|
updateWorldBlock(slot, inventory[slot]);
|
|
return stack;
|
|
}
|
|
ItemStack split = inventory[slot].splitStack(quantity);
|
|
if (inventory[slot].stackSize == 0)
|
|
{
|
|
inventory[slot] = null;
|
|
}
|
|
|
|
updateWorldBlock(slot, inventory[slot]);
|
|
return split;
|
|
}
|
|
else
|
|
{
|
|
return null;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onInventoryChanged ()
|
|
{
|
|
smeltery.updateTemperatures();
|
|
updateAir = true;
|
|
super.onInventoryChanged();
|
|
}
|
|
|
|
void updateWorldBlock (int slot, ItemStack itemstack)
|
|
{
|
|
CoordTuple air = structure.getAirByIndex(slot);
|
|
if (air != null)
|
|
{
|
|
TileEntity te = worldObj.getBlockTileEntity(air.x, air.y, air.z);
|
|
if (te != null && te instanceof TankAirLogic)
|
|
{
|
|
((TankAirLogic) te).setInventorySlotContents(0, itemstack);
|
|
}
|
|
}
|
|
}
|
|
|
|
static final int pixelLayer = 162;
|
|
|
|
//Do the Monster Mash~
|
|
public void distributeFluids ()
|
|
{
|
|
//Calculate liquids in each block
|
|
int size = structure.getAirLayerSize();
|
|
//HashMap<CoordTuple, LiquidDataInstance> blocks = new HashMap<CoordTuple, LiquidDataInstance>();
|
|
|
|
for (FluidStack fluid : multitank.fluidlist)
|
|
{
|
|
//Base calculations per liquid
|
|
LiquidData data = new LiquidData(fluid.amount, size);
|
|
int baseY = structure.airCoords.get(0).y;
|
|
int layerSize = structure.getAirLayerSize();
|
|
|
|
//Calculate where to distribute liquids
|
|
for (int i = 0; i < structure.airCoords.size(); i++)
|
|
{
|
|
LiquidDataInstance instance;
|
|
CoordTuple coord = structure.airCoords.get(i);
|
|
int height = 16 * (coord.y - baseY);
|
|
int position = i % layerSize;
|
|
|
|
if (!airUpdates.containsKey(coord))
|
|
{
|
|
instance = new LiquidDataInstance();
|
|
airUpdates.put(coord, instance);
|
|
}
|
|
else
|
|
{
|
|
instance = airUpdates.get(coord);
|
|
}
|
|
|
|
if (instance.openLayers() > 0) //This is capable of sending negative liquid sizes to blocks without the stopgap check
|
|
{
|
|
if (position > data.blocksWithExtra)
|
|
{
|
|
//Calculate open layers
|
|
int open = data.layers - height + 1;
|
|
if (open < 1) //Temporary stopgap check
|
|
continue;
|
|
if (open > instance.openLayers())
|
|
open = instance.openLayers();
|
|
|
|
//Copy fluid
|
|
FluidStack newFluid = fluid.copy();
|
|
newFluid.amount = pixelLayer * open;
|
|
instance.addFluid(open, newFluid);
|
|
|
|
//Subtract from total
|
|
data.totalAmount -= newFluid.amount;
|
|
if (data.totalAmount <= 0)
|
|
break;
|
|
}
|
|
else if (position == data.blocksWithExtra && data.leftovers > 0)
|
|
{
|
|
//Calculate open layers
|
|
int open = data.layers - height + 1;
|
|
if (open < 1) //Temporary stopgap check
|
|
continue;
|
|
boolean full = false;
|
|
if (open > instance.openLayers())
|
|
{
|
|
open = instance.openLayers();
|
|
full = true;
|
|
}
|
|
|
|
//Copy fluid
|
|
FluidStack newFluid = fluid.copy();
|
|
newFluid.amount = pixelLayer * open;
|
|
if (!full)
|
|
newFluid.amount += data.leftovers;
|
|
instance.addFluid(open, newFluid);
|
|
|
|
//Subtract from total
|
|
data.totalAmount -= newFluid.amount;
|
|
if (data.totalAmount <= 0)
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
//Calculate open layers
|
|
int open = data.layers - height;
|
|
if (open < 1) //Temporary stopgap check
|
|
continue;
|
|
if (open > instance.openLayers())
|
|
open = instance.openLayers();
|
|
|
|
//Copy fluid
|
|
FluidStack newFluid = fluid.copy();
|
|
newFluid.amount = pixelLayer * open;
|
|
instance.addFluid(open, newFluid);
|
|
|
|
//Subtract from total
|
|
data.totalAmount -= newFluid.amount;
|
|
if (data.totalAmount <= 0)
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Distribute liquids to each block
|
|
}
|
|
|
|
protected void updateFluidBlocks ()
|
|
{
|
|
Iterator iter = airUpdates.entrySet().iterator();
|
|
byte count = 0;
|
|
while (iter.hasNext() && count < 40)
|
|
{
|
|
Map.Entry pairs = (Map.Entry) iter.next();
|
|
CoordTuple coord = (CoordTuple) pairs.getKey();
|
|
TileEntity te = worldObj.getBlockTileEntity(coord.x, coord.y, coord.z);
|
|
if (te instanceof TankAirLogic)
|
|
{
|
|
((TankAirLogic) te).overrideFluids(((LiquidDataInstance) pairs.getValue()).fluids);
|
|
}
|
|
iter.remove();
|
|
count++;
|
|
}
|
|
}
|
|
|
|
public void updateAir ()
|
|
{
|
|
for (CoordTuple loc : structure.airCoords)
|
|
worldObj.markBlockForUpdate(loc.x, loc.y, loc.z);
|
|
}
|
|
|
|
class LiquidData
|
|
{
|
|
public int totalAmount;
|
|
public int layers;
|
|
public int leftovers;
|
|
public int blocksWithExtra;
|
|
|
|
LiquidData(int amount, int blocks)
|
|
{
|
|
totalAmount = amount;
|
|
int layerAmount = pixelLayer * blocks;
|
|
layers = amount / layerAmount;
|
|
leftovers = amount % pixelLayer;
|
|
blocksWithExtra = (amount % layerAmount) / pixelLayer;
|
|
}
|
|
}
|
|
|
|
class LiquidDataInstance
|
|
{
|
|
public ArrayList<FluidStack> fluids = new ArrayList<FluidStack>();
|
|
int layers = 0;
|
|
|
|
public int openLayers ()
|
|
{
|
|
return 16 - layers;
|
|
}
|
|
|
|
public void addFluid (int l, FluidStack fluid)
|
|
{
|
|
layers += l;
|
|
fluids.add(fluid);
|
|
}
|
|
}
|
|
|
|
/* Gui */
|
|
|
|
@Override
|
|
public Container getGuiContainer (InventoryPlayer inventoryplayer, World world, int x, int y, int z)
|
|
{
|
|
return new AdaptiveSmelteryContainer(inventoryplayer, this);
|
|
}
|
|
|
|
public int getTempForSlot (int slot)
|
|
{
|
|
return smeltery.activeTemps[slot];
|
|
}
|
|
|
|
public int getMeltingPointForSlot (int slot)
|
|
{
|
|
return smeltery.meltingTemps[slot];
|
|
}
|
|
|
|
@Override
|
|
public String getDefaultName ()
|
|
{
|
|
return "crafters.Smeltery";
|
|
}
|
|
|
|
/* Fluids */
|
|
|
|
@Override
|
|
public int fill (ForgeDirection from, FluidStack resource, boolean doFill)
|
|
{
|
|
return multitank.fill(resource, doFill);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain (ForgeDirection from, FluidStack resource, boolean doDrain)
|
|
{
|
|
return multitank.drain(resource.amount, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public FluidStack drain (ForgeDirection from, int maxDrain, boolean doDrain)
|
|
{
|
|
return multitank.drain(maxDrain, doDrain);
|
|
}
|
|
|
|
@Override
|
|
public boolean canFill (ForgeDirection from, Fluid fluid)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public boolean canDrain (ForgeDirection from, Fluid fluid)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
@Override
|
|
public FluidTankInfo[] getTankInfo (ForgeDirection from)
|
|
{
|
|
return multitank.getMultiTankInfo();
|
|
}
|
|
|
|
public int getFillState ()
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
/* NBT */
|
|
|
|
@Override
|
|
public void readFromNBT (NBTTagCompound tags)
|
|
{
|
|
super.readFromNBT(tags);
|
|
readNetworkNBT(tags);
|
|
|
|
structure.readFromNBT(tags);
|
|
multitank.readFromNBT(tags);
|
|
smeltery.readFromNBT(tags);
|
|
}
|
|
|
|
public void readNetworkNBT (NBTTagCompound tags)
|
|
{
|
|
direction = tags.getByte("Direction");
|
|
adjustInventory(tags.getInteger("InvSize"), false);
|
|
super.readInventoryFromNBT(tags);
|
|
|
|
structure.readNetworkNBT(tags);
|
|
multitank.readNetworkNBT(tags);
|
|
smeltery.readNetworkNBT(tags);
|
|
}
|
|
|
|
@Override
|
|
public void writeToNBT (NBTTagCompound tags)
|
|
{
|
|
super.writeToNBT(tags);
|
|
writeNetworkNBT(tags);
|
|
|
|
structure.writeToNBT(tags);
|
|
multitank.writeToNBT(tags);
|
|
smeltery.writeToNBT(tags);
|
|
}
|
|
|
|
public void writeNetworkNBT (NBTTagCompound tags)
|
|
{
|
|
tags.setByte("Direction", direction);
|
|
tags.setInteger("InvSize", inventory.length);
|
|
super.writeInventoryToNBT(tags);
|
|
|
|
structure.writeNetworkNBT(tags);
|
|
multitank.writeNetworkNBT(tags);
|
|
smeltery.writeNetworkNBT(tags);
|
|
}
|
|
|
|
@Override
|
|
public void onDataPacket (INetworkManager net, Packet132TileEntityData packet)
|
|
{
|
|
readNetworkNBT(packet.data);
|
|
worldObj.markBlockForRenderUpdate(xCoord, yCoord, zCoord);
|
|
}
|
|
|
|
@Override
|
|
public Packet getDescriptionPacket ()
|
|
{
|
|
NBTTagCompound tag = new NBTTagCompound();
|
|
writeNetworkNBT(tag);
|
|
return new Packet132TileEntityData(xCoord, yCoord, zCoord, 1, tag);
|
|
}
|
|
}
|