CC: Bundles

CC:Bundles

CC:Bundles allows CC:Tweaked turtles to equip and use vanilla Minecraft bundles as inventory peripherals.

• Regular bundles + all 16 dyed variants
• Preserves bundle color and contents when equipped/unequipped
• CC:Tweaked-style inventory API
• Bundle capacity utilities
• bundleCost item information
• Direct access to the turtle's inventory
• Dump bundle contents into the world

API

Method	Description
size()	Number of unique item variants
list()	List bundle contents
getItemDetail(slot)	Detailed item info, including bundleCost
getItemLimit(slot)	Item limit for a virtual slot
pushItems(toName, fromSlot [, limit [, toSlot]])	Move items out of the bundle
pullItems(fromName, fromSlot [, limit [, toSlot]])	Move items into the bundle
slotsFull()	Used capacity out of 64
slotsFree()	Remaining capacity out of 64
dump()	Dump all contents in front of the turtle

Inventory methods follow the conventions of CC:Tweaked's generic inventory peripheral.

Using a Bundle

Once equipped, wrap the bundle as a peripheral:

local bundle = peripheral.wrap("left")

or:

local bundle = peripheral.wrap("right")

Virtual Slots

Bundles do not have fixed inventory slots.

Each unique stored item variant is exposed as a virtual slot:

{
    [1] = {
        name = "minecraft:oak_planks",
        count = 12
    },

    [2] = {
        name = "minecraft:diamond",
        count = 3
    }
}

Items with different components or stored data are separate variants.

Virtual slot numbers may change when contents change.

size() returns the number of current virtual slots, not a fixed inventory size.

bundleCost

getItemDetail(slot) includes:

bundleCost

Capacity used by one item:

64-stackable item  = 1
16-stackable item  = 4
non-stackable item = 64

Example:

local item = bundle.getItemDetail(1)

print(item.name)
print(item.count)
print(item.bundleCost)

CC:Bundles also adds bundleCost to:

turtle.getItemDetail(slot, true)

The second argument must be true.

local item = turtle.getItemDetail(4, true)

if item then
    print(item.bundleCost)
end

This can be used with slotsFree() to determine how many items will fit:

local item = turtle.getItemDetail(4, true)

if item then
    local maxFit = math.floor(bundle.slotsFree() / item.bundleCost)

    bundle.pullItems(
        "turtle",
        4,
        math.min(item.count, maxFit)
    )
end

Moving Items

pullItems() moves items into the bundle:

bundle.pullItems(fromName, fromSlot [, limit [, toSlot]])

pushItems() moves items out of the bundle:

bundle.pushItems(toName, fromSlot [, limit [, toSlot]])

Both return the number of items moved.

Turtle Inventory

Turtle slot 4 → bundle:

bundle.pullItems("turtle", 4)

At most 8 items:

bundle.pullItems("turtle", 4, 8)

Bundle slot 1 → turtle:

bundle.pushItems("turtle", 1)

Into turtle slot 6:

bundle.pushItems("turtle", 1, 8, 6)

Other inventories use their normal peripheral names.

Bundle Capacity

bundle.slotsFull()
bundle.slotsFree()

Both use Minecraft's actual bundle capacity rules.

bundle.slotsFull() + bundle.slotsFree()

always equals:

64

Dumping Contents

local count = bundle.dump()

dump():

• Dumps the entire bundle in front of the turtle

Example: Find an Item

for slot, item in pairs(bundle.list()) do
    if item.name == "minecraft:diamond" then
        print(slot, item.count)
    end
end

Documentation

• CC:Tweaked Documentation
• Turtle API
• Peripheral API
• Generic Inventory Peripheral