Hi, I'm a novice modder (and coder), and I need your help...!!!

 

I have a working furnace with multiple input slots (1 fuel and 1 output). All basic functionality is working properly. I'd like to implement some additional behavior, but for the life of me I can't figure out how. I did an initial search and was surprised to turn up nothing about this. All the info I found was to set behaviors for the entire entity, not individual slots.

[*]I'd like to restrict maxstacksize for input slots to 1, and leave maxstacksize for fuel and output slots at default (64).

[*]I'd also like to be able to restrict valid ItemStack for input slots based on oredict tags (ore* and dust*)

 

PART 1

 

I've been able to get correct shift-click behavior with custom Slot class, custom mergeItemStack(), and transferStackInSlot() in the Container class. But this yields odd left-click behavior if implemented (left clicking an occupied input slot while holding a matching ItemStack withdraws the stack from the slot and increases the held stack, even past stacksize limits) so I've reverted it.

 

I also can't get automation (hoppers) to change behavior (round robin) or respect the custom inputSlot's stacksize limits, without setting the TileEntity'sgetInventoryStackLimit() to return 1 instead of 64. This of course causes problems for the fuel and output slots.

 

PART 2

 

Honestly have no clue where to begin. I looked through the oredict class, but couldn't find any way to make a given ItemStack return its oredict tag.

 

CODE

 

Tile Entity:

 

public class TileCupolaFurnace extends TileEntity implements ITickable, IInventory {

    // index 0-3 = input, 4 = fuel, 5 = output
    private ItemStack[] furnaceItemStacks = new ItemStack[6];

    private int burnTimeRemaining;  // number of ticks remaining on current piece of fuel
    private int fuelBurnTime;  // initial fuel value of the currently burning fuel
    private int[] itemCookTime = new int[4];   // current cook time for input slots

    private static final int COOK_TIME_FOR_COMPLETION = 400;  // the number of ticks to smelt

    @Override
    public int getSizeInventory() {
        return furnaceItemStacks.length;
    }

    @Override
    public ItemStack getStackInSlot(int index) {
        return furnaceItemStacks[index];
    }

    @Override
    public ItemStack decrStackSize(int index, int count) {
        ItemStack stackInSlot = furnaceItemStacks[index];
        ItemStack stackRemoved;

        if (stackInSlot == null)
            return null;

        if (stackInSlot.stackSize <= count) {
            stackRemoved = stackInSlot;
            setInventorySlotContents(index, null);
        } else {
            stackRemoved = stackInSlot.splitStack(count);
            if (stackInSlot.stackSize == 0)
                setInventorySlotContents(index, null);
        }
        markDirty();
        return stackRemoved;
    }

    @Override
    public void setInventorySlotContents(int index, ItemStack stack) {
        furnaceItemStacks[index] = stack;

        if (stack != null && stack.stackSize > getInventoryStackLimit())
            stack.stackSize = getInventoryStackLimit();

        markDirty();
    }

    @Override
    public int getInventoryStackLimit() {
        return 64;
    }

    @Override
    public boolean isUseableByPlayer(EntityPlayer player) {
        if (this.worldObj.getTileEntity(this.pos) != this) return false;
        final double X_CENTRE_OFFSET = 0.5;
        final double Y_CENTRE_OFFSET = 0.5;
        final double Z_CENTRE_OFFSET = 0.5;
        final double MAXIMUM_DISTANCE_SQ = 8.0 * 8.0;
        return player.getDistanceSq(pos.getX() + X_CENTRE_OFFSET, pos.getY() + Y_CENTRE_OFFSET, pos.getZ() + Z_CENTRE_OFFSET) < MAXIMUM_DISTANCE_SQ;
    }

    @Override
    public boolean isItemValidForSlot(int index, ItemStack stack) {
        return index != 5 && (index != 4 || isItemFuel(stack));
    }

    @Override
    public void update() {
        for (int i = 0; i < 4; i++) {
            ItemStack input = furnaceItemStacks[i];
            if (input != null && canSmelt(i)) {
                startBurnFuel();
                cookItem(i);
            }
            else {
                if (input == null) itemCookTime[i] = 0;
                if (itemCookTime[i] > 0 && !isBurning()) itemCookTime[i]--;
            }
        }
        if (isBurning()) burnTimeRemaining--;
    }

    private boolean isBurning() {
        return this.burnTimeRemaining > 0;
    }

    private void startBurnFuel() {
        if (!this.isBurning()) {
            boolean inventoryChanged = false;
            if (this.furnaceItemStacks[4] != null && isItemFuel(this.furnaceItemStacks[4]) && this.furnaceItemStacks[4].stackSize > 0) {
                this.burnTimeRemaining = this.fuelBurnTime = getFuelBurnTime(this.furnaceItemStacks[4]);
                this.furnaceItemStacks[4].stackSize--;
                inventoryChanged = true;
                if (this.furnaceItemStacks[4].stackSize == 0)
                    this.furnaceItemStacks[4] = null;
            }
            if (inventoryChanged) markDirty();
        }
    }

    private boolean canSmelt(int index) {
        ItemStack input = this.furnaceItemStacks[index];
        ItemStack output = FurnaceRecipes.instance().getSmeltingResult(input);
        if (output == null) return false;
        if (this.furnaceItemStacks[5] == null) return true;
        if (!this.furnaceItemStacks[5].isItemEqual(output)) return false;
        int result = this.furnaceItemStacks[5].stackSize + output.stackSize;
        return result <= getInventoryStackLimit() && result <= this.furnaceItemStacks[5].getMaxStackSize();
    }

    private void cookItem(int index) {
        if (isBurning())
            itemCookTime[index]++;
        if (itemCookTime[index] == COOK_TIME_FOR_COMPLETION) {
            smeltItem(index);
            itemCookTime[index] = 0;
        }
    }

    private void smeltItem(int index) {
        ItemStack smeltingResult = FurnaceRecipes.instance().getSmeltingResult(this.furnaceItemStacks[index]);

        if (this.furnaceItemStacks[5] == null)
            this.furnaceItemStacks[5] = smeltingResult.copy();
        else if (this.furnaceItemStacks[5].getItem() == smeltingResult.getItem())
            this.furnaceItemStacks[5].stackSize += smeltingResult.stackSize;
        this.furnaceItemStacks[index].stackSize--;
        if (furnaceItemStacks[index].stackSize <= 0)
            furnaceItemStacks[index] = null;
        markDirty();
    }

    public boolean isItemFuel(ItemStack stack) {
        return stack != null && getFuelBurnTime(stack) > 0;
    }

    private int getFuelBurnTime(ItemStack stack) {
        if (stack == null) {
            return 0;
        } else {
            Item item = stack.getItem();

            if (item instanceof ItemBlock && Block.getBlockFromItem(item) != Blocks.air) {
                Block block = Block.getBlockFromItem(item);
                if (block == Blocks.coal_block) return 16000;
                else return 0;
            }
            if (item == Items.coal) return 1600;
        }
        return 0;
    }

    public int getBurnRemainingSeconds() {
        if (burnTimeRemaining <= 0) return 0;
        return burnTimeRemaining / 20;
    }

    public double getBurnRemainingRatio() {
        if (burnTimeRemaining <= 0) return 0;
        double ratio = (double) burnTimeRemaining / (double) fuelBurnTime;
        return MathHelper.clamp_double(ratio, 0.0, 1.0);
    }

    public double getCookProgressRatio(int index) {
        double ratio = (double) itemCookTime[index] / (double) COOK_TIME_FOR_COMPLETION;
        return MathHelper.clamp_double(ratio, 0.0, 1.0);
    }

    @Override
    public void writeToNBT(NBTTagCompound compound) {
        super.writeToNBT(compound);

        NBTTagList tagList = new NBTTagList();

        for (int i = 0; i < this.furnaceItemStacks.length; i++) {
            if (this.furnaceItemStacks[i] != null) {
                NBTTagCompound stackTag = new NBTTagCompound();
                stackTag.setByte("Slot", (byte) i);
                this.furnaceItemStacks[i].writeToNBT(stackTag);
                tagList.appendTag(stackTag);
            }
        }
        compound.setTag("Items", tagList);
        compound.setInteger("burnTimeRemaining", this.burnTimeRemaining);
        compound.setInteger("fuelBurnTime", this.fuelBurnTime);
        compound.setTag("itemCookTime", new NBTTagIntArray(this.itemCookTime));
    }

    @Override
    public void readFromNBT(NBTTagCompound compound) {
        super.readFromNBT(compound);

        final byte NBT_TYPE = 10;
        NBTTagList tagList = compound.getTagList("Items", NBT_TYPE);

        for (int i = 0; i < tagList.tagCount(); i++) {
            NBTTagCompound stackTag = tagList.getCompoundTagAt(i);
            int slot = stackTag.getByte("Slot") & 255;
            this.furnaceItemStacks[slot] = ItemStack.loadItemStackFromNBT(stackTag);
        }
        this.burnTimeRemaining = compound.getInteger("burnTimeRemaining");
        this.fuelBurnTime = compound.getInteger("fuelBurnTime");
        this.itemCookTime = Arrays.copyOf(compound.getIntArray("itemCookTime"), 4);
    }

    @Override
    public void clear() {
        Arrays.fill(furnaceItemStacks, null);
    }

    @Override
    public String getName() {
        return "container.cupola_furnace.name";
    }

    @Override
    public boolean hasCustomName() {
        return false;
    }

    @Override
    public IChatComponent getDisplayName() {
        return this.hasCustomName() ? new ChatComponentText(this.getName()) : new ChatComponentTranslation(this.getName());
    }

    @Override
    public Packet getDescriptionPacket() {
        NBTTagCompound nbtTagCompound = new NBTTagCompound();
        writeToNBT(nbtTagCompound);
        int metadata = getBlockMetadata();
        return new S35PacketUpdateTileEntity(this.pos, metadata, nbtTagCompound);
    }

    @Override
    public void onDataPacket(NetworkManager net, S35PacketUpdateTileEntity pkt) {
        readFromNBT(pkt.getNbtCompound());
    }

    @Override
    public ItemStack removeStackFromSlot(int index) {
        ItemStack stackremoved = furnaceItemStacks[index];

        if (stackremoved != null)
            setInventorySlotContents(index, null);

        return stackremoved;
    }

    @Override
    public void openInventory(EntityPlayer player) {
    }

    @Override
    public void closeInventory(EntityPlayer player) {
    }

    @Override
    public int getField(int id) {
        if (id == 0) return this.burnTimeRemaining;
        if (id == 1) return this.fuelBurnTime;
        if (id > 1 && id <= 5) return itemCookTime[id - 2];
        System.err.println("Invalid field ID in TileCupolaFurnace.getField:" + id);
        return 0;
    }

    @Override
    public void setField(int id, int value) {
        if (id == 0) this.burnTimeRemaining = value;
        else if (id == 1) this.fuelBurnTime = value;
        else if (id > 1 && id <= 5) this.itemCookTime[id - 2] = value;
        else System.err.println("Invalid field ID in TileCupolaFurnace.setField:" + id);
    }

    @Override
    public int getFieldCount() {
        return 6;
    }
}

 

 

Container:

 

public class ContainerCupolaFurnace extends Container {

    /**
     * SLOTS                            INDEX
     * <p>
     * 0-8 = hotbar slots               0-8
     * 9-35 = player inventory slots    9-35
     * <p>
     * 36-41 = furnace slots
     * 36-39 = input slots              0-3
     * 40 = fuel slot                   4
     * 41 = output slot                 5
     */

    private TileCupolaFurnace tileCupolaFurnace;

    public ContainerCupolaFurnace(InventoryPlayer invPlayer, TileCupolaFurnace tileCupolaFurnace) {
        this.tileCupolaFurnace = tileCupolaFurnace;

        // hotbar slots
        for (int x = 0; x < 9; x++) {
            addSlotToContainer(new Slot(invPlayer, x, 8 + 18 * x, 134));
        }
        // player inv slots
        for (int y = 0; y < 3; ++y) {
            for (int x = 0; x < 9; ++x) {
                addSlotToContainer(new Slot(invPlayer, x + y * 9 + 9, 8 + x * 18, 76 + y * 18));
            }
        }
        // furnace input slots
        for (int y = 0; y < 2; y++) {
            for (int x = 0; x < 2; x++) {
                addSlotToContainer(new inputSlot(tileCupolaFurnace, x + y * 2, 24 + x * 21, 24 + y * 18));
            }
        }
        // furnace fuel slot
        addSlotToContainer(new Slot(tileCupolaFurnace, 4, 80, 51));
        //furnace output slot
        addSlotToContainer(new Slot(tileCupolaFurnace, 5, 125, 27));
    }

    @Override
    public boolean canInteractWith(EntityPlayer playerIn) {
        return this.tileCupolaFurnace.isUseableByPlayer(playerIn);
    }

    @Override
    public ItemStack transferStackInSlot(EntityPlayer playerIn, int index) {
        Slot sourceSlot = this.inventorySlots.get(index);
        if (sourceSlot == null || !sourceSlot.getHasStack()) return null;
        ItemStack sourceStack = sourceSlot.getStack();
        ItemStack copyOfSourceStack = sourceStack.copy();

        if (index >= 0 && index < 36) {
            if (tileCupolaFurnace.isItemFuel(sourceStack)) {
                if (!mergeItemStack(sourceStack, 40, 41, false)) {
                    return null;
                }
            }
            else if (!mergeItemStack(sourceStack, 36, 40, false)) {
                return null;
            }
        } else if (index >= 36 && index < 42) {
            if (!mergeItemStack(sourceStack, 0, 36, false)) {
                return null;
            }
        } else {
            System.err.print("Invalid slotIndex:" + index);
            return null;
        }

        if (sourceStack.stackSize == 0) {
            sourceSlot.putStack(null);
        } else {
            sourceSlot.onSlotChanged();
        }

        sourceSlot.onPickupFromSlot(playerIn, sourceStack);
        return copyOfSourceStack;
    }

//    private boolean mergeInputStack(ItemStack stack, int startIndex, int endIndex, boolean useEndIndex) {
//        boolean success = false;
//        int index = startIndex;
//
//        if (useEndIndex)
//            index = endIndex - 1;
//
//        Slot slot;
//        ItemStack stackInSlot;
//
//        if (stack.isStackable()) {
//            while (stack.stackSize > 0 && (!useEndIndex && index < endIndex || useEndIndex && index >= startIndex)) {
//                slot = this.inventorySlots.get(index);
//                stackInSlot = slot.getStack();
//
//                if (stackInSlot != null && stackInSlot.getItem() == stack.getItem() && (!stack.getHasSubtypes() || stack.getMetadata() == stackInSlot.getMetadata()) && ItemStack.areItemStackTagsEqual(stack, stackInSlot)) {
//                    int l = stackInSlot.stackSize + stack.stackSize;
//                    int maxsize = Math.min(stack.getMaxStackSize(), slot.getItemStackLimit(stack));
//
//                    if (l <= maxsize) {
//                        stack.stackSize = 0;
//                        stackInSlot.stackSize = l;
//                        slot.onSlotChanged();
//                        success = true;
//                    } else if (stackInSlot.stackSize < maxsize) {
//                        stack.stackSize -= stack.getMaxStackSize() - stackInSlot.stackSize;
//                        stackInSlot.stackSize = stack.getMaxStackSize();
//                        slot.onSlotChanged();
//                        success = true;
//                    }
//                }
//
//                if (useEndIndex) {
//                    --index;
//                } else {
//                    ++index;
//                }
//            }
//        }
//
//        if (stack.stackSize > 0) {
//            if (useEndIndex) {
//                index = endIndex - 1;
//            } else {
//                index = startIndex;
//            }
//
//            while (!useEndIndex && index < endIndex || useEndIndex && index >= startIndex && stack.stackSize > 0) {
//                slot = this.inventorySlots.get(index);
//                stackInSlot = slot.getStack();
//
//                // Forge: Make sure to respect isItemValid in the slot.
//                if (stackInSlot == null && slot.isItemValid(stack)) {
//                    if (stack.stackSize < slot.getItemStackLimit(stack)) {
//                        slot.putStack(stack.copy());
//                        stack.stackSize = 0;
//                        success = true;
//                        break;
//                    } else {
//                        ItemStack newstack = stack.copy();
//                        newstack.stackSize = slot.getItemStackLimit(stack);
//                        slot.putStack(newstack);
//                        stack.stackSize -= slot.getItemStackLimit(stack);
//                        success = true;
//                    }
//                }
//
//                if (useEndIndex) {
//                    --index;
//                } else {
//                    ++index;
//                }
//            }
//        }
//
//        return success;
//    }

    @Override
    public void onContainerClosed(EntityPlayer playerIn) {
        super.onContainerClosed(playerIn);
        this.tileCupolaFurnace.closeInventory(playerIn);
    }

    private int[] cachedFields;

    @Override
    public void detectAndSendChanges() {
        super.detectAndSendChanges();

        boolean allFieldsHaveChanged = false;
        boolean fieldHasChanged[] = new boolean[tileCupolaFurnace.getFieldCount()];
        if (cachedFields == null) {
            cachedFields = new int[tileCupolaFurnace.getFieldCount()];
            allFieldsHaveChanged = true;
        }
        for (int i = 0; i < cachedFields.length; ++i) {
            if (allFieldsHaveChanged || cachedFields[i] != tileCupolaFurnace.getField(i)) {
                cachedFields[i] = tileCupolaFurnace.getField(i);
                fieldHasChanged[i] = true;
            }
        }
        for (ICrafting icrafting : this.crafters) {
            for (int fieldID = 0; fieldID < tileCupolaFurnace.getFieldCount(); ++fieldID) {
                if (fieldHasChanged[fieldID]) {
                    icrafting.sendProgressBarUpdate(this, fieldID, cachedFields[fieldID]);
                }
            }
        }
    }

    private class inputSlot extends Slot {

        inputSlot(IInventory inventoryIn, int index, int xPosition, int yPosition) {
            super(inventoryIn, index, xPosition, yPosition);
        }

        @Override
        public int getSlotStackLimit() {
            return 64;
        }
    }

    @SideOnly(Side.CLIENT)
    @Override
    public void updateProgressBar(int id, int data) {
        tileCupolaFurnace.setField(id, data);
    }
}

 

 

Thanks for any help!

Use your custom slot for the slot that should have a max stack size of 1 and return 1 for the Slot#getSlotStackLimit method.

 

However, the vanilla #mergeStackInSlot implementations DO NOT check the slot's stack limit (at least as of 1.8 - maybe it has changed), and also has trouble handling slot limits of 1.

 

Here is an implementation I came up with for #mergeStackInSlot - there are others out there as well that do the same thing.

 

As for the shift-clicking moving items into the wrong slots, that has to do with how you choose to implement #transferStackInSlot - you can find some information about that in this tutorial, though I recommend you skip to the final spoiler section first, as that is the most recent.

!!!

 

Hey, it's you! Your tutorials (and others') are the reason I've gotten this far. Thanks for putting those together!

 

I've re-implemented custom Slot classes and MergeStackInSlot() to handle the Container interactions. This time I've also implemented more comprehensive logic in TileEntity.isItemValidForSlot() to handle automated insertion, to catch itemstack.stackSize > 1 for those slots. Hopefully that'll cover all of it.

 

The errant clicking behavior actually happens on regular click and not shift click, as described in the OP:

(If for whatever reason the itemstack in the slot has stacksize > 1) left clicking an occupied input slot while holding a matching ItemStack withdraws the stack from the slot and increases the held stack, even past stacksize limits, so I've reverted it.

 

Hopefully now it's a moot point, unless there's a way to get an itemstack > 1 into a slot that I'm missing. I still want to fix that behavior, just in case. Thanks for the help, and again for the tutorials.