Yes it does wait up
Container Hunter Bench
package mhfc.net.client.container;
import mhfc.net.client.gui.slot.SlotHunterBench;
import mhfc.net.common.core.registry.MHFCBlockRegistry;
import mhfc.net.common.crafting.MHFCCraftingManager;
import mhfc.net.common.tile.TileHunterBench;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.InventoryPlayer;
import net.minecraft.inventory.Container;
import net.minecraft.inventory.IInventory;
import net.minecraft.inventory.InventoryCraftResult;
import net.minecraft.inventory.InventoryCrafting;
import net.minecraft.inventory.Slot;
import net.minecraft.item.ItemStack;
import net.minecraft.util.math.BlockPos;
import net.minecraft.world.World;
public class ContainerHunterBench extends Container {
public InventoryCrafting craftMatrix = new InventoryCrafting(this, 3, 5);
public IInventory craftResult = new InventoryCraftResult();
private World worldObj;
private int posX;
private int posY;
private int posZ;
public ContainerHunterBench(InventoryPlayer par1InventoryPlayer, World par2World, TileHunterBench tileEntity, int x,int y,int z) {
this.worldObj = par2World;
this.posX = x;
this.posY = y;
this.posZ = z;
this.addSlotToContainer(
new SlotHunterBench(
par1InventoryPlayer.player,
this.craftMatrix,
this.craftResult,
0,
124 + 8,
35 + 1));
int var6;
int var7;
for (var6 = 0; var6 < 5; ++var6) {
for (var7 = 0; var7 < 3; ++var7) {
this.addSlotToContainer(new Slot(this.craftMatrix, var7 + var6 * 3, 30 + var7 * 18, var6 * 18 + 15));
}
}
for (var6 = 0; var6 < 3; ++var6) {
for (var7 = 0; var7 < 9; ++var7) {
this.addSlotToContainer(
new Slot(par1InventoryPlayer, var7 + var6 * 9 + 9, 158 + var7 * 18, var6 * 18 + 15));
}
}
for (var6 = 0; var6 < 9; ++var6) {
this.addSlotToContainer(new Slot(par1InventoryPlayer, var6, 158 + var6 * 18, 84));
}
for (var6 = 0; var6 < 7; ++var6) {
Slot s = new Slot(tileEntity, var6 + 3, var6 * 18 + 229, 28) {
@Override
public boolean isItemValid(ItemStack stack) {
return false;
}
@Override
public boolean canTakeStack(EntityPlayer p) {
return false;
}
};
this.addSlotToContainer(s);
}
for (var6 = 0; var6 < 7; ++var6) {
this.addSlotToContainer(new Slot(tileEntity, var6 + 10, var6 * 18 + 229, 191) {
});
}
this.addSlotToContainer(new Slot(tileEntity, TileHunterBench.resultSlot, 280, 146) {
@Override
public boolean isItemValid(ItemStack stack) {
return false;
}
});
this.addSlotToContainer(new Slot(tileEntity, TileHunterBench.fuelSlot, 354, 168));
this.addSlotToContainer(new Slot(tileEntity, TileHunterBench.outputSlot, 335, 146));
for (var6 = 0; var6 < 4; ++var6) {
for (var7 = 0; var7 < 9; ++var7) {
this.addSlotToContainer(new Slot(par1InventoryPlayer, var7 + var6 * 9, 7 + var6 * 18, var7 * 18 + 28));
}
}
this.onCraftMatrixChanged(this.craftMatrix);
}
@Override
public void onCraftMatrixChanged(IInventory par1IInventory) {
this.craftResult.setInventorySlotContents(0,MHFCCraftingManager.getInstance().findMatchingRecipe(this.craftMatrix, this.worldObj));
}
@Override
public boolean canInteractWith(EntityPlayer par1EntityPlayer) {
return this.worldObj.getBlockState(new BlockPos(this.posX, this.posY, this.posZ))
.getBlock() != MHFCBlockRegistry.getRegistry().mhfcblockhunterbench
? false
: par1EntityPlayer.getDistanceSq(this.posX + 0.5D, this.posY + 0.5D, this.posZ + 0.5D) <= 64.0D;
}
@Override
public void onContainerClosed(EntityPlayer par1EntityPlayer) {
super.onContainerClosed(par1EntityPlayer);
if (!this.worldObj.isRemote) {
for (int i = 0; i < 15; ++i) {
ItemStack itemstack = this.craftMatrix.getStackInSlot(i);
if (itemstack != null) {
par1EntityPlayer.dropItem(itemstack, false);
}
}
}
}
@Override
public ItemStack transferStackInSlot(EntityPlayer par1EntityPlayer, int par2) {
ItemStack var3 = null;
Slot var4 = this.inventorySlots.get(par2);
if (var4 != null && var4.getHasStack()) {
ItemStack var5 = var4.getStack();
var3 = var5.copy();
if (par2 == 0) {
if (!this.mergeItemStack(var5, 10, 46, true)) {
return null;
}
var4.onSlotChange(var5, var3);
} else if (par2 >= 10 && par2 < 37) {
if (!this.mergeItemStack(var5, 37, 46, false)) {
return null;
}
} else if (par2 >= 37 && par2 < 46) {
if (!this.mergeItemStack(var5, 10, 37, false)) {
return null;
}
} else if (!this.mergeItemStack(var5, 10, 46, false)) {
return null;
}
if (var5.getCount() == 0) {
var4.putStack((ItemStack) null);
} else {
var4.onSlotChanged();
}
if (var5.getCount() == var3.getCount()) {
return null;
}
var4.onTake(par1EntityPlayer, var5);
}
return var3;
}
@Override
public boolean canMergeSlot(ItemStack par1ItemStack, Slot par2Slot) {
return par2Slot.inventory != this.craftResult && super.canMergeSlot(par1ItemStack, par2Slot);
}
}
Tile Entity
package mhfc.net.common.tile;
import mhfc.net.common.core.registry.MHFCEquipementRecipeRegistry;
import mhfc.net.common.crafting.recipes.equipment.EquipmentRecipe;
import mhfc.net.common.crafting.recipes.equipment.EquipmentRecipe.RecipeType;
import mhfc.net.common.index.ResourceInterface;
import mhfc.net.common.network.PacketPipeline;
import mhfc.net.common.network.message.bench.MessageBeginCrafting;
import mhfc.net.common.network.message.bench.MessageBenchRefreshRequest;
import mhfc.net.common.network.message.bench.MessageCancelRecipe;
import mhfc.net.common.network.message.bench.MessageCraftingUpdate;
import mhfc.net.common.network.message.bench.MessageSetRecipe;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.inventory.IInventory;
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;
import net.minecraft.tileentity.TileEntityFurnace;
import net.minecraft.util.ITickable;
import net.minecraft.util.text.ITextComponent;
import net.minecraft.util.text.TextComponentTranslation;
import net.minecraftforge.fml.relauncher.Side;
import net.minecraftforge.fml.relauncher.SideOnly;
public class TileHunterBench extends TileEntity implements ITickable, IInventory, TileMHFCUpdateStream {
public static final int outputSlot = 2;
public static final int fuelSlot = 0;
public static final int resultSlot = 1;
private ItemStack fuelStack;
private ItemStack resultStack;
private ItemStack[] recipeStacks;
private ItemStack[] inputStacks;
private ItemStack outputStack;
/**
* How hot the furnace currently is
*/
volatile private int heatStrength;
/**
* How hot the fire produced by the currently burning item is
*/
volatile private int heatFromItem;
/**
* How long the furnace stays hot
*/
volatile private int heatLength;
/**
* How long the furnace stayed hot initially with the burning item
*/
private int heatLengthInit;
/**
* How long the current item has been smelting
*/
volatile private int itemSmeltDuration;
/**
* The selected recipe
*/
private EquipmentRecipe recipe;
/**
* If the recipe is currently worked on
*/
volatile private boolean workingMHFCBench;
public TileHunterBench() {
recipeStacks = new ItemStack[7];
inputStacks = new ItemStack[recipeStacks.length];
workingMHFCBench = false;
heatLengthInit = 1;
}
@Override
public int getSizeInventory() {
return recipeStacks.length + inputStacks.length + 3;
}
@Override
public void update() {
if (heatLength > 0) {
--heatLength;
heatStrength = getNewHeat(heatStrength, heatFromItem);
if (TileHunterBench.this.workingMHFCBench && recipe != null && heatStrength >= recipe.getRequiredHeat()) {
++itemSmeltDuration;
}
} else {
if (fuelStack != null && TileHunterBench.this.workingMHFCBench) {
heatLength = TileEntityFurnace.getItemBurnTime(fuelStack);
heatLengthInit = heatLength;
heatFromItem = getItemHeat(fuelStack);
decrStackSize(fuelSlot, 1);
if (!world.isRemote) {
sendUpdateCraft();
}
} else {
heatStrength = getNewHeat(heatStrength, 0);
}
}
if (recipe != null && itemSmeltDuration >= recipe.getDuration()) {
finishRecipe();
}
}
private void finishRecipe() {
if (world.isRemote) {
return;
}
inputStacks = new ItemStack[inputStacks.length];
outputStack = resultStack.copy();
workingMHFCBench = false;
itemSmeltDuration = 0;
sendUpdateCraft();
}
/**
* Forces the client to end the crafting and put the stack into the output slot. Unused
*
* @param stack
*/
@SideOnly(Side.CLIENT)
public void forceEndCrafting(ItemStack stack) {
outputStack = stack;
inputStacks = new ItemStack[inputStacks.length];
TileHunterBench.this.workingMHFCBench = false;
itemSmeltDuration = 0;
}
public boolean isWorking() {
return TileHunterBench.this.workingMHFCBench;
}
public void changeRecipe(EquipmentRecipe recipe) {
if (world.isRemote) {
sendSetRecipe(recipe);
}
if (recipe != this.recipe) {
cancelRecipe();
setRecipe(recipe);
}
}
protected void setRecipe(EquipmentRecipe recipe) {
if (recipe == null) {
recipeStacks = new ItemStack[7];
this.recipe = null;
resultStack = null;
} else {
resultStack = recipe.getRecipeOutput();
this.recipe = recipe;
setIngredients(recipe);
}
}
public void setIngredients(EquipmentRecipe recipe) {
this.recipeStacks = recipe.getRequirements(7);
}
public static int getItemHeat(ItemStack itemStack) {
if (itemStack == null) {
return 0;
}
if (itemStack.getItem() == Item.getItemById(327)) {
return 1000;
}
return 200;
}
private int getNewHeat(int heatOld, int heatAim) {
int diff = heatAim - heatOld;
// Some math to confuse the hell out of everyone reading this
double change = Math.ceil(Math.log(Math.abs(diff) + 1.0));
return heatOld + (int) (Math.ceil(change / 3.0) * Math.signum(diff));
}
@Override
public ItemStack decrStackSize(int slot, int count) {
markDirty();
if (count <= 0) {
return null;
}
// FIXME: can do that better...
if (slot > recipeStacks.length + 2) {
ItemStack stack = inputStacks[slot - recipeStacks.length - 3];
if (stack == null) {
return null;
}
cancelRecipe();
if (count > stack.getCount()) {
count = stack.getCount();
}
if (count == stack.getCount()) {
inputStacks[slot - recipeStacks.length - 3] = null;
return stack;
}
return stack.splitStack(count);
}
if (slot > 2) {
return null; // You cant get anything from the recipe slots
} else if (slot == outputSlot) {
if (outputStack == null) {
return null;
}
if (count > outputStack.getCount()) {
count = outputStack.getCount();
}
if (count == outputStack.getCount()) {
ItemStack fuel = outputStack;
outputStack = null;
return fuel;
}
return outputStack.splitStack(count);
} else if (slot == resultSlot) {
return null;
} else {
if (fuelStack == null) {
return null;
}
if (count > fuelStack.getCount()) {
count = fuelStack.getCount();
}
if (count == fuelStack.getCount()) {
ItemStack fuel = fuelStack;
fuelStack = null;
return fuel;
}
return fuelStack.splitStack(count);
}
}
/**
* Resets all working progress but leaves the recipe set
*/
public void cancelRecipe() {
if (world.isRemote) {
sendCancelRecipe();
}
TileHunterBench.this.workingMHFCBench = false;
itemSmeltDuration = 0;
}
@Override
public ItemStack removeStackFromSlot(int index) {
ItemStack stack = getStackInSlot(index);
setInventorySlotContents(index, null);
return stack;
}
@Override
public ItemStack getStackInSlot(int i) {
if (i < 0 || i >= getSizeInventory()) {
return null;
} else if (i >= recipeStacks.length + 3) {
return inputStacks[i - 3 - recipeStacks.length];
} else if (i >= 3) {
return recipeStacks[i - 3];
} else if (i == outputSlot) {
return outputStack;
} else if (i == resultSlot) {
return resultStack;
} else {
return fuelStack;
}
}
@Override
public void setInventorySlotContents(int i, ItemStack itemstack) {
if (i < 0 || i >= getSizeInventory()) {
return;
}
if (i >= recipeStacks.length + 3) {
inputStacks[i - recipeStacks.length - 3] = itemstack;
} else if (i >= 3) {
recipeStacks[i - 3] = itemstack;
} else if (i == outputSlot) {
outputStack = itemstack;
} else if (i == resultSlot) {
resultStack = itemstack;
} else if (i == fuelSlot) {
fuelStack = itemstack;
}
markDirty();
}
public boolean isInvNameLocalized() {
return false;
}
@Override
public boolean isEmpty() {
for (ItemStack stack : inputStacks) {
if (!stack.isEmpty()) {
return false;
}
}
return true;
}
@Override
public int getInventoryStackLimit() {
return 64;
}
@Override
public boolean isUsableByPlayer(EntityPlayer entityplayer) {
return getDistanceSq(entityplayer.posX, entityplayer.posY, entityplayer.posZ) <= 64.0f;
}
@Override
public boolean isItemValidForSlot(int i, ItemStack itemstack) {
return (i == fuelSlot && TileEntityFurnace.isItemFuel(itemstack))
|| (i > recipeStacks.length + 2 && i < recipeStacks.length * 2 + 3);
}
@Override
public ITextComponent getDisplayName() {
return new TextComponentTranslation(getName());
}
public boolean beginCrafting() {
if (world.isRemote) {
sendBeginCraft();
}
if (canBeginCrafting()) {
TileHunterBench.this.workingMHFCBench = true;
}
return TileHunterBench.this.workingMHFCBench;
}
@SideOnly(Side.CLIENT)
private void sendBeginCraft() {
PacketPipeline.networkPipe.sendToServer(new MessageBeginCrafting(this));
}
@SideOnly(Side.CLIENT)
private void sendSetRecipe(EquipmentRecipe recipeToSend) {
PacketPipeline.networkPipe.sendToServer(new MessageSetRecipe(this, recipeToSend));
}
@SideOnly(Side.CLIENT)
private void sendCancelRecipe() {
PacketPipeline.networkPipe.sendToServer(new MessageCancelRecipe(this));
}
@Override
public void refreshState() {
if (world.isRemote) {
PacketPipeline.networkPipe.sendToServer(new MessageBenchRefreshRequest(this));
}
}
private void sendUpdateCraft() {
PacketPipeline.networkPipe.sendToAll(new MessageCraftingUpdate(this));
}
public boolean canBeginCrafting() {
return (recipe != null) && matchesInputOutput() && (outputStack == null);
}
protected boolean matchesInputOutput() {
for (int i = 0; i < inputStacks.length; i++) {
if (!ItemStack.areItemStacksEqual(inputStacks[i], recipeStacks[i])) {
return false;
}
}
return true;
}
public int getHeatStrength() {
return heatStrength;
}
public int getBurningItemHeat() {
return heatFromItem;
}
public int getHeatLength() {
return heatLength;
}
public int getHeatLengthOriginal() {
return heatLengthInit;
}
public int getItemSmeltDuration() {
return itemSmeltDuration;
}
@Override
public void readFromNBT(NBTTagCompound nbtTag) {
super.readFromNBT(nbtTag);
readCustomUpdate(nbtTag);
NBTTagList items = nbtTag.getTagList("Items", 10);
for (int a = 0; a < items.tagCount(); a++) {
NBTTagCompound stack = items.getCompoundTagAt(a);
byte id = stack.getByte("Slot");
if (id >= 0 && id < getSizeInventory()) {
setInventorySlotContents(id, new ItemStack(stack));
}
}
}
@Override
public NBTTagCompound writeToNBT(NBTTagCompound nbtTag) {
nbtTag = super.writeToNBT(nbtTag);
storeCustomUpdate(nbtTag);
NBTTagList itemsStored = new NBTTagList();
for (int a = 0; a < getSizeInventory(); a++) {
ItemStack s = getStackInSlot(a);
if (s != null) {
NBTTagCompound tag = new NBTTagCompound();
tag.setByte("Slot", (byte) a);
s.writeToNBT(tag);
itemsStored.appendTag(tag);
}
}
nbtTag.setTag("Items", itemsStored);
return nbtTag;
}
public EquipmentRecipe getRecipe() {
return recipe;
}
private static final String heatStrID = "heatStrength";
private static final String heatFromItemID = "heatFromItem";
private static final String heatLengthID = "heatLength";
private static final String heatLengthInitID = "heatLengthInit";
private static final String itemSmeltDurationID = "itemSmeltDuration";
private static final String workingID = "workingID";
private static final String recipeTypeID = "recipeType";
private static final String recipeIDID = "recipeID";
@Override
public void storeCustomUpdate(NBTTagCompound nbtTag) {
nbtTag.setInteger(heatStrID, heatStrength);
nbtTag.setInteger(heatFromItemID, heatFromItem);
nbtTag.setInteger(heatLengthID, heatLength);
nbtTag.setInteger(heatLengthInitID, heatLengthInit);
nbtTag.setInteger(itemSmeltDurationID, itemSmeltDuration);
nbtTag.setBoolean(workingID, TileHunterBench.this.workingMHFCBench);
RecipeType type = recipe != null ? recipe.getRecipeType() : RecipeType.MHFC;
int recipeID = MHFCEquipementRecipeRegistry.getIDFor(recipe);
nbtTag.setInteger(recipeTypeID, type.ordinal());
nbtTag.setInteger(recipeIDID, recipeID);
}
@Override
public void readCustomUpdate(NBTTagCompound nbtTag) {
heatStrength = nbtTag.getInteger(heatStrID);
heatFromItem = nbtTag.getInteger(heatFromItemID);
heatLength = nbtTag.getInteger(heatLengthID);
heatLengthInit = nbtTag.getInteger(heatLengthInitID);
itemSmeltDuration = nbtTag.getInteger(itemSmeltDurationID);
TileHunterBench.this.workingMHFCBench = nbtTag.getBoolean(workingID);
int irecType = nbtTag.getInteger(recipeTypeID);
int recId = nbtTag.getInteger(recipeIDID);
RecipeType recType = RecipeType.values()[irecType];
setRecipe(MHFCEquipementRecipeRegistry.getRecipeFor(recId, recType));
}
@Override
public String getName() {
return "container" + ResourceInterface.block_hunterbench_name;
}
@Override
public boolean hasCustomName() {
return false;
}
@Override
public void openInventory(EntityPlayer player) {}
@Override
public void closeInventory(EntityPlayer player) {}
@Override
public void clear() {
for (int i = 0; i < getSizeInventory(); ++i) {
removeStackFromSlot(i);
}
}
@Override
public int getField(int id) {
throw new IllegalArgumentException("No such field: " + id);
}
@Override
public void setField(int id, int value) {
throw new IllegalArgumentException("No such field: " + id);
}
@Override
public int getFieldCount() {
return 0;
}
}
I dont have my own inventory crafting i uses vanilla.