net.kernelpanicsoft.archie.transfer¶

Types¶

`ArchieCapabilityExposure`¶

object ArchieCapabilityExposure

Exposes ArchieItemStorage/ArchieFluidStorage/ArchieEnergyStorage to third-party mods' pipes/hoppers/etc, by registering against Common Storage Lib's ItemApi/FluidApi/EnergyApi BLOCK lookups - which are, unlike a lookup you'd build yourself via BlockLookup.create, the real, already-canonical singletons Common Storage Lib itself wires straight through to each platform's native capability system (Fabric Transfer API's ItemStorage.SIDED/FluidStorage.SIDED, NeoForge's Capabilities.ItemHandler.BLOCK/Capabilities.FluidHandler.BLOCK). Registering here makes a block entity's storage visible to any mod querying those native systems directly - no dependency on Common Storage Lib (or Archie) required on the consuming side.

`ArchieEnergyStorage`¶

@Serializable



(with = ArchieEnergyStorage.Serializer::class)class ArchieEnergyStorage(capacity: Long, onUpdate: () -> Unit = {}) : ValueStorage, UpdateManager<NbtTag>

Archie's platform-agnostic energy buffer: implements Common Storage Lib's ValueStorage - the energy analogue of the CommonStorage<ItemResource>/CommonStorage<FluidResource> ArchieItemStorage/ArchieFluidStorage implement - plus Archie's NBT serialization for save/load, mirroring their shape.

`ArchieFluidSlot`¶

@Serializable



(with = ArchieFluidSlot.Serializer::class)class ArchieFluidSlot(
    limit: Long, 
    filter: Predicate<FluidResource> = Predicate { true }, 
    onUpdate: () -> Unit = {}
) : StorageSlot<FluidResource> , UpdateManager<NbtTag>

A single resource-backed slot inside an ArchieFluidStorage, capped at limit. Tracks a FluidResource + amount internally while exposing plain FluidStack access via getFluid/set.

`ArchieFluidStorage`¶

@Serializable



(with = ArchieFluidStorage.Serializer::class)open class ArchieFluidStorage : CommonStorage<FluidResource> , UpdateManager<NbtTag>

The fluid analogue of ArchieItemStorage: a fixed-size list of ArchieFluidSlots, each capped at limit, implementing Common Storage Lib's CommonStorage and Archie's NBT serialization (via Serializer) for save/load.

`ArchieItemMenuSlot`¶

class ArchieItemMenuSlot(
    storage: ArchieItemStorage, 
    val filter: Predicate<ItemStack> = Predicate { true }, 
    slot: Int, 
    x: Int, 
    y: Int, 
    owningMenu: ComposeContainerMenuBase<*>
) : Slot

A vanilla Slot that bridges one slot of an ArchieItemStorage into a ComposeContainerMenuBase, so net.minecraft.world.inventory machinery (shift-click, drag, etc.) can operate on it directly. Created by ComposeContainerMenuBase from a handler(group, storage, filter) registration; not usually constructed directly.

`ArchieItemSlot`¶

@Serializable



(with = ArchieItemSlot.Serializer::class)class ArchieItemSlot(filter: Predicate<ItemResource> = Predicate { true }, onUpdate: () -> Unit = {}) : StorageSlot<ItemResource> , UpdateManager<NbtTag>

A single resource-backed slot inside an ArchieItemStorage. Tracks an ItemResource + amount internally (for Common Storage Lib's resource-based insert/extract) while exposing plain ItemStack access via getItem/set.

`ArchieItemStorage`¶

@Serializable



(with = ArchieItemStorage.Serializer::class)open class ArchieItemStorage : CommonStorage<ItemResource> , UpdateManager<NbtTag>

Archie's platform-agnostic item container: a fixed-size list of ArchieItemSlots that implements Common Storage Lib's CommonStorage (resource-based insert/extract for capability interop) and Archie's NBT serialization (via Serializer) for save/load.

`CommonStorageMenuSlot`¶

class CommonStorageMenuSlot(
    storage: CommonStorage<ItemResource>, 
    val filter: Predicate<ItemStack> = Predicate { true }, 
    slot: Int, 
    x: Int, 
    y: Int, 
    owningMenu: ComposeContainerMenuBase<*>
) : Slot

A vanilla Slot over one slot of any CommonStorage of items, so net.minecraft.world.inventory machinery (shift-click, drag, hotbar swap, ...) can operate on a storage that is not an ArchieItemStorage.

`VanillaMenuSlot`¶

class VanillaMenuSlot(
    storage: AbstractVanillaContainer, 
    val filter: Predicate<ItemStack> = Predicate { true }, 
    slot: Int, 
    x: Int, 
    y: Int, 
    owningMenu: ComposeContainerMenuBase<*>
) : Slot

The ArchieItemMenuSlot equivalent for adapting an existing vanilla-style AbstractVanillaContainer (rather than an ArchieItemStorage) into a ComposeContainerMenuBase. Created by ComposeContainerMenuBase from a handler(group, storage, filter) registration; not usually constructed directly.

Functions¶

`exposeEnergyStorage`¶

fun <T : BlockEntity> RegistrySupplier<BlockEntityType<T>>.exposeEnergyStorage(selector: (T) -> ValueStorage?)

fun <T : BlockEntity> RegistrySupplier<BlockEntityType<T>>.exposeEnergyStorage(selector: (T, Direction?) -> ValueStorage?)

fun <T : BlockEntity> BlockEntityType<T>.exposeEnergyStorage(selector: (T) -> ValueStorage?)

exposeEnergyStorage overload for a selector that doesn't need the query direction.

fun <T : BlockEntity> BlockEntityType<T>.exposeEnergyStorage(selector: (T, Direction?) -> ValueStorage?)

See ArchieCapabilityExposure. Exposes this block entity type's ArchieEnergyStorage to EnergyApi.BLOCK.

`exposeFluidStorage`¶

fun <T : BlockEntity> RegistrySupplier<BlockEntityType<T>>.exposeFluidStorage(selector: (T) -> CommonStorage<FluidResource>?)

fun <T : BlockEntity> RegistrySupplier<BlockEntityType<T>>.exposeFluidStorage(selector: (T, Direction?) -> CommonStorage<FluidResource>?)

fun <T : BlockEntity> BlockEntityType<T>.exposeFluidStorage(selector: (T) -> CommonStorage<FluidResource>?)

exposeFluidStorage overload for a selector that doesn't need the query direction.

fun <T : BlockEntity> BlockEntityType<T>.exposeFluidStorage(selector: (T, Direction?) -> CommonStorage<FluidResource>?)

See ArchieCapabilityExposure. Exposes this block entity type's ArchieFluidStorage to FluidApi.BLOCK.

`exposeItemStorage`¶

fun <T : BlockEntity> RegistrySupplier<BlockEntityType<T>>.exposeItemStorage(selector: (T) -> CommonStorage<ItemResource>?)

fun <T : BlockEntity> RegistrySupplier<BlockEntityType<T>>.exposeItemStorage(selector: (T, Direction?) -> CommonStorage<ItemResource>?)

fun Item.exposeItemStorage(selector: (ItemStack, ItemContext) -> CommonStorage<ItemResource>?)

Exposes this item's ArchieItemStorage (e.g. a bag/backpack's contents) to ItemApi.ITEM.

fun <T : BlockEntity> BlockEntityType<T>.exposeItemStorage(selector: (T) -> CommonStorage<ItemResource>?)

exposeItemStorage overload for a selector that doesn't need the query direction.

fun <T : BlockEntity> BlockEntityType<T>.exposeItemStorage(selector: (T, Direction?) -> CommonStorage<ItemResource>?)

See ArchieCapabilityExposure. Exposes this block entity type's ArchieItemStorage to ItemApi.BLOCK.