AdaptiveSmelteryLogic.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.inventory.AdaptiveSmelteryContainer;
import tconstruct.library.blocks.AdaptiveInventoryLogic;
import tconstruct.library.component.IComponentHolder;
import tconstruct.library.component.LogicComponent;
import tconstruct.library.component.MultiFluidTank;
import tconstruct.library.util.CoordTuple;
import tconstruct.library.util.IActiveLogic;
import tconstruct.library.util.IMasterLogic;
import tconstruct.library.util.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, TContent.smeltery, TContent.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);
    }
}