ExtractorContainer.java

package sketchd2.minecraft.chemcraft;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.ICrafting;
import net.minecraft.inventory.Slot;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;

public class ExtractorContainer extends Container{
	private ExtractorTileEntity extractor;
	private int lastExtractTime;
	private int lastPowerTime;
	
	public ExtractorContainer(InventoryPlayer par1, ExtractorTileEntity par2){
		this.extractor = par2;
		this.addSlotToContainer(new Slot(par2,0,56,17));
		this.addSlotToContainer(new ExtractorSlot(par1.player,extractor, 1,116,17));
		this.addSlotToContainer(new ExtractorSlot(par1.player,extractor, 2,116,53));
		
		int i;
		for(i=0;i<3;++i){
			for(int j=0;j<9;++j){
				this.addSlotToContainer(new Slot(par1,j+i*9+9,8+j*18,84+i*18));
			}
		}
		
		for(i=0;i<9;++i){
			this.addSlotToContainer(new Slot(par1,i,8+i*18,142));
		}
	}
	
	public void addCraftingToCrafters(ICrafting par1){
		super.addCraftingToCrafters(par1);
		par1.sendProgressBarUpdate(this, 0, this.extractor.powerRemaining);
		par1.sendProgressBarUpdate(this, 1, this.extractor.extractionPower);
	}
	
	public void detectAndSendChanges(){
		super.detectAndSendChanges();
		for(int i=0;i<this.crafters.size();++i){
			ICrafting icrafting = (ICrafting)this.crafters.get(i);
			if(this.lastExtractTime!=this.extractor.powerRemaining){
				icrafting.sendProgressBarUpdate(this, 0, this.extractor.powerRemaining);
			}
			if(this.lastPowerTime!=this.extractor.extractionPower){
				icrafting.sendProgressBarUpdate(this, 1, this.extractor.extractionPower);
			}
		}
		
		//this.extractor.setInventorySlotContents(0, (ItemStack)this.inventorySlots.get(0));
		//this.inventorySlots.set(1, this.extractor.getStackInSlot(1));
		//this.inventorySlots.set(2, this.extractor.getStackInSlot(2));
		this.lastExtractTime=this.extractor.powerRemaining;
		this.lastPowerTime=this.extractor.extractionPower;
	}
	
	@SideOnly(Side.CLIENT)
	public void updateProgressBar(int par1, int par2){
		if(par1==0){
			this.extractor.powerRemaining=par2;
		}
		if(par1==1){
			this.extractor.extractionPower=par2;
		}
	}
	
	public boolean canInteractWith(EntityPlayer par1){
		return this.extractor.isUseableByPlayer(par1);
	}
	@Override
	public ItemStack transferStackInSlot(EntityPlayer par1, int par2){
		ItemStack itemstack = null;
		Slot slot = (Slot)this.inventorySlots.get(par2);
		if(slot!=null&&slot.getHasStack()){
			ItemStack itemstack1 = slot.getStack();
			itemstack = itemstack1.copy();
			if(par2==2){
				if(!this.mergeItemStack(itemstack1, 3, 39, true)){
					return null;
				}
				slot.onSlotChange(itemstack1,itemstack);
			}else if(par2!=1&&par2!=0){
				if(ExtractorRecipes.extracting().getFirstExtractResult(itemstack1)!=null){
					if(!this.mergeItemStack(itemstack1, 0, 1, false)){
						return null;
					}
				}else if(par2>=3&&par2<30){
					if(!this.mergeItemStack(itemstack1, 30, 39, false)){
						return null;
					}
				}else if(par2>=30&&par2<39&&!this.mergeItemStack(itemstack1, 3, 30, false)){
					return null;
				}
			}else if(!this.mergeItemStack(itemstack1, 3, 39, false)){
				return null;
			}
			if(itemstack1.stackSize==0){
				slot.putStack((ItemStack)null);
			}else{
				slot.onSlotChanged();
			}
			if(itemstack1.stackSize==itemstack.stackSize){
				return null;
			}
			slot.onPickupFromSlot(par1, itemstack1);
		}
		return itemstack;
	}
}

ExtractorTileEntity.java

package sketchd2.minecraft.chemcraft;

import cpw.mods.fml.relauncher.Side;
import cpw.mods.fml.relauncher.SideOnly;
import net.minecraft.block.Block;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.ISidedInventory;
import net.minecraft.item.Item;
import net.minecraft.item.ItemStack;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.nbt.NBTTagList;
import net.minecraft.tileentity.TileEntity;

public class ExtractorTileEntity extends TileEntity implements ISidedInventory {
	private static final int[] slots_top = new int[] { 0 };
	private static final int[] slots_bottom = new int[] { 2, 1 };
	private static final int[] slots_sides = new int[] { 2, 1 };

	private ItemStack[] extractorItemStacks = new ItemStack[3];
	public int extractionPower;// power remaining, equiv to burntime
	public int powerRemaining;// equiv to currentburntime
	public int processTime;// equiv to cooktime
	private String field_94130_e;

	public int getSizeInventory() {
		return this.extractorItemStacks.length;
	}

	public ItemStack getStackInSlot(int par1) {
		return this.extractorItemStacks[par1];
	}

	public ItemStack decrStackSize(int par1, int par2) {
		if (this.extractorItemStacks[par1] != null) {
			ItemStack itemstack;
			if (this.extractorItemStacks[par1].stackSize <= par2) {
				itemstack = this.extractorItemStacks[par1];
				this.extractorItemStacks[par1] = null;
				return itemstack;
			} else {
				itemstack = this.extractorItemStacks[par1].splitStack(par2);
				if (this.extractorItemStacks[par1].stackSize == 0) {
					this.extractorItemStacks[par1] = null;
				}
				return null;
			}
		} else {
			return null;
		}
	}

	public ItemStack getStackInSlotOnClosing(int par1) {
		if (this.extractorItemStacks[par1] != null) {
			ItemStack itemstack = this.extractorItemStacks[par1];
			this.extractorItemStacks[par1] = null;
			return itemstack;
		} else {
			return null;
		}
	}

	public void setInventorySlotContents(int par1, ItemStack par2) {
		this.extractorItemStacks[par1] = par2;
		if (par2 != null && par2.stackSize > this.getInventoryStackLimit()) {
			par2.stackSize = this.getInventoryStackLimit();
		}
	}

	public String getInvName() {
		return this.isInvNameLocalized() ? this.field_94130_e
				: "container.chemcraft.extractor";
	}

	public boolean isInvNameLocalized() {
		return this.field_94130_e != null && this.field_94130_e.length() > 0;
	}

	public void setGuiDisplayName(String par1) {
		this.field_94130_e = par1;
	}

	public int getInventoryStackLimit() {
		return 64;
	}

	public boolean isUseableByPlayer(EntityPlayer par1EntityPlayer) {
		return !par1EntityPlayer.isSneaking();
	}

	public void openChest() {
	}

	public void closeChest() {
	}

	public boolean isItemValidForSlot(int par1, ItemStack par2) {
		return par1 == 1 || par1 == 2 ? false : true;
	}

	public int[] getAccessibleSlotsFromSide(int par1) {
		return par1 == 0 ? slots_bottom : (par1 == 1 ? slots_top : slots_sides);
	}

	public boolean canInsertItem(int par1, ItemStack par2, int par3) {
		return this.isItemValidForSlot(par1, par2);
	}

	public boolean canExtractItem(int par1, ItemStack par2, int par3) {
		return par3 != 0 || par1 != 1;
	}

	public void readFromNBT(NBTTagCompound par1) {
		super.readFromNBT(par1);
		NBTTagList nbttaglist = par1.getTagList("Items");
		this.extractorItemStacks = new ItemStack[this.getSizeInventory()];
		for (int i = 0; i < nbttaglist.tagCount(); ++i) {
			NBTTagCompound par2 = (NBTTagCompound) nbttaglist.tagAt(i);
			byte b0 = par2.getByte("Slot");
			if (b0 >= 0 && b0 < this.extractorItemStacks.length) {
				this.extractorItemStacks[b0] = ItemStack
						.loadItemStackFromNBT(par2);
			}
		}
		this.powerRemaining = par1.getShort("BurnTime");
		this.processTime = par1.getShort("CookTime");
		this.extractionPower = par1.getShort("Power");

		if (par1.hasKey("CustomName")) {
			this.field_94130_e = par1.getString("CustomName");
		}
	}

	public void writeToNBT(NBTTagCompound par1) {
		super.writeToNBT(par1);
		par1.setShort("BurnTime", (short) this.powerRemaining);
		par1.setShort("CookTime", (short) this.processTime);
		NBTTagList taglist = new NBTTagList();
		for (int i = 0; i < this.extractorItemStacks.length; ++i) {
			if (this.extractorItemStacks[i] != null) {
				NBTTagCompound par2 = new NBTTagCompound();
				par2.setByte("Slot", (byte) i);
				this.extractorItemStacks[i].writeToNBT(par1);
				taglist.appendTag(par2);
			}
		}
		par1.setTag("Items", taglist);
		if (this.isInvNameLocalized()) {
			par1.setString("CustomName", this.field_94130_e);
		}
	}

	@SideOnly(Side.CLIENT)
	public int getExtractProgressScaled(int par1) {
		return this.processTime * par1 / 200;// par1 is the scale factor, 200 is
												// the amount of seperations
	}

	@SideOnly(Side.CLIENT)
	public int getPowerTimeRemainingScaled(int par1) {
		if (this.powerRemaining == 0) {
			this.powerRemaining = 200;
		}
		return this.extractionPower * par1 / this.powerRemaining;
	}

	public boolean isWorking() {
		return this.extractionPower > 0;
	}

	// updating every tick
	public void updateEntity() {
		boolean flag = this.processTime > 0;// is machine running
		boolean flag1 = false;// successfully started extracting
		boolean flag2 = false;// whether inventory needs updating
		if (this.worldObj.isRemote) {
			if (this.processTime == 0 && this.canExtract()) {
				this.extractionPower = getItemExtractPower(this.extractorItemStacks[0]);
				if (this.extractionPower <= this.powerRemaining) {
					flag1 = true;// sucessfully begun extraction
					flag2 = true;
					this.processTime = this.extractionPower;
				}
			}
			if (this.isWorking() && this.canExtract()) {
				--this.processTime;
				if (this.processTime == 0) {
					this.extractItem();
					flag2 = true;
				}
			} else {
				this.processTime = 0;
			}
			if (flag != this.processTime > 0) {
				flag2 = true;
				ExtractorBlock.updateBlockState(this.processTime > 0,
						this.worldObj, this.xCoord, this.yCoord, this.zCoord);
			}
		}
		if (flag2) {
			this.onInventoryChanged();
		}
	}

	private boolean canExtract() {
		if (this.extractorItemStacks[0] == null) {
			return false;
		} else {
			ItemStack is1 = ExtractorRecipes.extracting()
					.getFirstExtractResult(this.extractorItemStacks[0]);
			ItemStack is2 = ExtractorRecipes.extracting()
					.getSecondExtractResult(this.extractorItemStacks[0]);
			if (is1 == null)
				return false;
			if (this.extractorItemStacks[1] == null
					&& this.extractorItemStacks[2] == null)
				return true;
			if (!this.extractorItemStacks[1].isItemEqual(is1)
					|| (!this.extractorItemStacks[2].isItemEqual(is2) && this.extractorItemStacks[2] != null))
				return false;
			int result1 = extractorItemStacks[1].stackSize + is1.stackSize;
			int result2 = extractorItemStacks[2].stackSize + is2.stackSize;
			return (result1 <= getInventoryStackLimit()
					&& result1 <= is1.getMaxStackSize()
					&& result2 <= getInventoryStackLimit() && result2 < is2
					.getMaxStackSize());
		}
	}

	public void extractItem() {
		if (this.canExtract()) {
			ItemStack is1 = ExtractorRecipes.extracting()
					.getFirstExtractResult(this.extractorItemStacks[0]);
			ItemStack is2 = ExtractorRecipes.extracting()
					.getSecondExtractResult(this.extractorItemStacks[0]);

			if (this.extractorItemStacks[1] == null) {
				this.extractorItemStacks[1] = is1.copy();
			} else if (this.extractorItemStacks[1].isItemEqual(is1)) {
				extractorItemStacks[1].stackSize += is1.stackSize;
			}
			if (this.extractorItemStacks[2] == null) {
				this.extractorItemStacks[2] = is2.copy();
			} else if (this.extractorItemStacks[2].isItemEqual(is2)) {
				extractorItemStacks[2].stackSize += is2.stackSize;
			}

			--this.extractorItemStacks[0].stackSize;

			if (this.extractorItemStacks[0].stackSize <= 0) {
				this.extractorItemStacks[0] = null;
			}
		}
	}

	public static int getItemExtractPower(ItemStack par0) {
		if (par0 == null) {
			return 0;
		} else {
			int i = ExtractorRecipes.extracting().getPowerRequirement(par0);
			return i;
		}
	}
}