@shipload/sdk 1.0.0-next.8 → 1.0.0-next.9

package/src/entities/extractor.ts

@@ -0,0 +1,144 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {CoordinatesType} from '../types'
+import {Location} from './location'
+import {ScheduleAccessor} from '../scheduling/accessor'
+import {InventoryAccessor} from './inventory-accessor'
+import type {EntityInventory} from './entity-inventory'
+import type {PackedModuleInput} from './ship'
+import {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, MODULE_GATHERER, MODULE_GENERATOR} from '../capabilities/modules'
+import {computeGathererCapabilities, computeGeneratorCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
+import {getItem} from '../data/catalog'
+
+export interface ExtractorStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
+
+export class Extractor extends ServerContract.Types.entity_info {
+    private _sched?: ScheduleAccessor
+    private _inv?: InventoryAccessor
+
+    get name(): string {
+        return this.entity_name
+    }
+
+    get entityClass(): 'building' {
+        return 'building'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
+    get inv(): InventoryAccessor {
+        this._inv ??= new InventoryAccessor(this)
+        return this._inv
+    }
+
+    get inventory(): EntityInventory[] {
+        return this.inv.items
+    }
+
+    get sched(): ScheduleAccessor {
+        this._sched ??= new ScheduleAccessor(this)
+        return this._sched
+    }
+
+    get isIdle(): boolean {
+        return this.is_idle
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get totalCargoMass(): UInt64 {
+        return this.inv.totalMass
+    }
+
+    get maxCapacity(): UInt64 {
+        return UInt64.from(this.capacity)
+    }
+
+    get availableCapacity(): UInt64 {
+        const cargo = this.totalCargoMass
+        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
+    }
+
+    get isFull(): boolean {
+        return this.totalCargoMass.gte(this.maxCapacity)
+    }
+
+    get totalMass(): UInt64 {
+        const hull = this.hullmass ? UInt64.from(this.hullmass) : UInt64.from(0)
+        return hull.adding(this.totalCargoMass)
+    }
+}
+
+export interface ExtractorCapabilities {
+    generator?: {capacity: number; recharge: number}
+    gatherer?: {yield: number; drain: number; depth: number; speed: number}
+}
+
+export function computeExtractorCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): ExtractorCapabilities {
+    const out: ExtractorCapabilities = {}
+
+    const genModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GENERATOR)
+    if (genModules.length > 0) {
+        let totalCapacity = 0
+        let totalRecharge = 0
+        for (const m of genModules) {
+            const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalCapacity += applySlotMultiplier(caps.capacity, amp)
+            totalRecharge += applySlotMultiplier(caps.recharge, amp)
+        }
+        out.generator = {
+            capacity: clampUint16(totalCapacity),
+            recharge: clampUint16(totalRecharge),
+        }
+    }
+
+    const gathModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_GATHERER)
+    if (gathModules.length > 0) {
+        let totalYield = 0
+        let totalDrain = 0
+        let maxDepth = 0
+        let totalSpeed = 0
+        for (const m of gathModules) {
+            const tier = getItem(m.itemId).tier
+            const caps = computeGathererCapabilities(
+                decodeCraftedItemStats(m.itemId, m.stats),
+                tier
+            )
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalYield += applySlotMultiplier(caps.yield, amp)
+            totalDrain += caps.drain
+            if (caps.depth > maxDepth) maxDepth = caps.depth
+            totalSpeed += applySlotMultiplier(caps.speed, amp)
+        }
+        out.gatherer = {
+            yield: clampUint16(totalYield),
+            drain: totalDrain,
+            depth: maxDepth,
+            speed: clampUint16(totalSpeed),
+        }
+    }
+
+    return out
+}

package/src/entities/makers.ts

@@ -3,8 +3,13 @@ import {ServerContract} from '../contracts'
 import {type PackedModuleInput, Ship, type ShipStateInput} from './ship'
 import {computeWarehouseCapabilities, Warehouse, type WarehouseStateInput} from './warehouse'
 import {Container, type ContainerStateInput} from './container'
-import {ITEM_SHIP_T1_PACKED, ITEM_WAREHOUSE_T1_PACKED} from '../data/item-ids'
-import {getEntityLayout} from '../data/recipes-runtime'
+import {Extractor, computeExtractorCapabilities, type ExtractorStateInput} from './extractor'
+import {
+    ITEM_EXTRACTOR_T1_PACKED,
+    ITEM_SHIP_T1_PACKED,
+    ITEM_WAREHOUSE_T1_PACKED,
+} from '../data/item-ids'
+import {getEntityLayout, type EntitySlot} from '../data/recipes-runtime'
 import {itemMetadata} from '../data/metadata'
 import {getItem} from '../data/catalog'
 import {
@@ -14,6 +19,7 @@ import {
     moduleSlotTypeToCode,
 } from '../capabilities/modules'
 import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
+import type {InstalledModule} from './slot-multiplier'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 
 function assignModulesToSlots(
@@ -56,19 +62,22 @@ function assignModulesToSlots(
     )
 }
 
-function decodePackedInput(m: PackedModuleInput): {itemId: number; stats: bigint} {
-    return {
-        itemId: Number(UInt16.from(m.itemId).value.toString()),
-        stats: BigInt(UInt64.from(m.stats).toString()),
-    }
+function toInstalledModules(entries: ServerContract.Types.module_entry[]): InstalledModule[] {
+    const installed: InstalledModule[] = []
+    entries.forEach((entry, slotIndex) => {
+        if (!entry.installed) return
+        installed.push({
+            slotIndex,
+            itemId: Number(UInt16.from(entry.installed.item_id).value.toString()),
+            stats: BigInt(UInt64.from(entry.installed.stats).toString()),
+        })
+    })
+    return installed
 }
 
-function computeStorageBonus(
-    decoded: {itemId: number; stats: bigint}[],
-    baseCapacity: number
-): number {
+function computeStorageBonus(modules: InstalledModule[], baseCapacity: number): number {
     let totalBonus = 0
-    for (const m of decoded) {
+    for (const m of modules) {
         if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
         const stats = decodeCraftedItemStats(m.itemId, m.stats)
         const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
@@ -78,15 +87,16 @@ function computeStorageBonus(
 }
 
 function deriveShipFromModules(
-    modules: PackedModuleInput[],
+    moduleEntries: ServerContract.Types.module_entry[],
+    layout: EntitySlot[],
     baseCapacity: number
 ): {
     capabilities: ReturnType<typeof computeShipCapabilities>
     finalCapacity: number
 } {
-    const decoded = modules.map(decodePackedInput)
-    const capabilities = computeShipCapabilities(decoded)
-    const totalBonus = computeStorageBonus(decoded, baseCapacity)
+    const installed = toInstalledModules(moduleEntries)
+    const capabilities = computeShipCapabilities(installed, layout)
+    const totalBonus = computeStorageBonus(installed, baseCapacity)
     return {capabilities, finalCapacity: baseCapacity + totalBonus}
 }
 
@@ -109,10 +119,12 @@ export function makeShip(state: ShipStateInput): Ship {
     if (state.schedule) info.schedule = state.schedule
 
     let moduleEntries: ServerContract.Types.module_entry[] = []
+    const shipLayout = getEntityLayout(ITEM_SHIP_T1_PACKED)?.slots ?? []
     if (state.modules && state.modules.length > 0) {
         moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
         const {capabilities, finalCapacity} = deriveShipFromModules(
-            state.modules,
+            moduleEntries,
+            shipLayout,
             state.capacity ?? 0
         )
         if (capabilities.engines) info.engines = capabilities.engines
@@ -152,17 +164,18 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     if (state.schedule) info.schedule = state.schedule
 
     let moduleEntries: ServerContract.Types.module_entry[] = []
+    const warehouseLayout = getEntityLayout(ITEM_WAREHOUSE_T1_PACKED)?.slots ?? []
     if (state.modules && state.modules.length > 0) {
         moduleEntries = assignModulesToSlots(
             ITEM_WAREHOUSE_T1_PACKED,
             state.modules,
             'Warehouse T1'
         )
-        const decoded = state.modules.map(decodePackedInput)
-        const capabilities = computeWarehouseCapabilities(decoded)
+        const installed = toInstalledModules(moduleEntries)
+        const capabilities = computeWarehouseCapabilities(installed, warehouseLayout)
         if (capabilities.loaders) info.loaders = capabilities.loaders
 
-        const totalBonus = computeStorageBonus(decoded, state.capacity)
+        const totalBonus = computeStorageBonus(installed, state.capacity)
         info.capacity = UInt32.from(state.capacity + totalBonus)
     } else {
         moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
@@ -174,6 +187,44 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     return new Warehouse(entityInfo)
 }
 
+export function makeExtractor(state: ExtractorStateInput): Extractor {
+    const info: Record<string, unknown> = {
+        type: Name.from('extractor'),
+        id: UInt64.from(state.id),
+        owner: Name.from(state.owner),
+        entity_name: state.name,
+        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
+        cargomass: UInt32.from(0),
+        cargo: state.cargo || [],
+        is_idle: !state.schedule,
+        current_task_elapsed: UInt32.from(0),
+        current_task_remaining: UInt32.from(0),
+        pending_tasks: [],
+    }
+    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
+    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
+    if (state.schedule) info.schedule = state.schedule
+    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+
+    const moduleEntries = assignModulesToSlots(
+        ITEM_EXTRACTOR_T1_PACKED,
+        state.modules ?? [],
+        'Extractor T1'
+    )
+    if (state.modules && state.modules.length > 0) {
+        const layout = getEntityLayout(ITEM_EXTRACTOR_T1_PACKED)?.slots ?? []
+        const installed = toInstalledModules(moduleEntries)
+        const capabilities = computeExtractorCapabilities(installed, layout)
+        if (capabilities.generator) info.generator = capabilities.generator
+        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
+    }
+
+    info.modules = moduleEntries
+
+    const entityInfo = ServerContract.Types.entity_info.from(info)
+    return new Extractor(entityInfo)
+}
+
 export function makeContainer(state: ContainerStateInput): Container {
     const entityInfo = ServerContract.Types.entity_info.from({
         type: Name.from('container'),

package/src/entities/ship-deploy.ts

@@ -9,6 +9,10 @@ import {
     MODULE_LOADER,
 } from '../capabilities/modules'
 import {getItem} from '../data/catalog'
+import type {EntitySlot} from '../data/recipes-runtime'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+
+export type {InstalledModule}
 
 export function computeShipHullCapabilities(stats: Record<string, number>): {
     hullmass: number
@@ -193,7 +197,8 @@ export interface ShipCapabilities {
 }
 
 export function computeShipCapabilities(
-    modules: {itemId: number; stats: bigint}[]
+    modules: InstalledModule[],
+    layout: EntitySlot[]
 ): ShipCapabilities {
     const ship: ShipCapabilities = {}
 
@@ -203,7 +208,7 @@ export function computeShipCapabilities(
         let totalDrain = 0
         for (const m of engineModules) {
             const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalDrain += caps.drain
         }
         ship.engines = {thrust: totalThrust, drain: totalDrain}
@@ -217,10 +222,14 @@ export function computeShipCapabilities(
         let totalRecharge = 0
         for (const m of generatorModules) {
             const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalCapacity += caps.capacity
-            totalRecharge += caps.recharge
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalCapacity += applySlotMultiplier(caps.capacity, amp)
+            totalRecharge += applySlotMultiplier(caps.recharge, amp)
+        }
+        ship.generator = {
+            capacity: clampUint16(totalCapacity),
+            recharge: clampUint16(totalRecharge),
         }
-        ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
     }
 
     const gathererModules = modules.filter(
@@ -237,12 +246,18 @@ export function computeShipCapabilities(
                 decodeCraftedItemStats(m.itemId, m.stats),
                 tier
             )
-            totalYield += caps.yield
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalYield += applySlotMultiplier(caps.yield, amp)
             totalDrain += caps.drain
             if (caps.depth > maxDepth) maxDepth = caps.depth
-            totalSpeed += caps.speed
+            totalSpeed += applySlotMultiplier(caps.speed, amp)
+        }
+        ship.gatherer = {
+            yield: clampUint16(totalYield),
+            drain: totalDrain,
+            depth: maxDepth,
+            speed: clampUint16(totalSpeed),
         }
-        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: maxDepth, speed: totalSpeed}
     }
 
     const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)
@@ -252,13 +267,15 @@ export function computeShipCapabilities(
         let totalDrain = 0
         for (const m of haulerModules) {
             const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const eff = applySlotMultiplier(caps.efficiency, getSlotAmp(layout, m.slotIndex))
             totalCapacity += caps.capacity
-            weightedEffNum += caps.efficiency * caps.capacity
+            weightedEffNum += eff * caps.capacity
             totalDrain += caps.drain
         }
+        const efficiency = totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0
         ship.hauler = {
             capacity: totalCapacity,
-            efficiency: totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0,
+            efficiency: clampUint16(efficiency),
             drain: totalDrain,
         }
     }
@@ -271,10 +288,14 @@ export function computeShipCapabilities(
         for (const m of loaderModules) {
             const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalQuantity += caps.quantity
         }
-        ship.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+        ship.loaders = {
+            mass: totalMass,
+            thrust: clampUint16(totalThrust),
+            quantity: totalQuantity,
+        }
     }
 
     const crafterModules = modules.filter(
@@ -285,10 +306,10 @@ export function computeShipCapabilities(
         let totalDrain = 0
         for (const m of crafterModules) {
             const caps = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalSpeed += caps.speed
+            totalSpeed += applySlotMultiplier(caps.speed, getSlotAmp(layout, m.slotIndex))
             totalDrain += caps.drain
         }
-        ship.crafter = {speed: totalSpeed, drain: totalDrain}
+        ship.crafter = {speed: clampUint16(totalSpeed), drain: totalDrain}
     }
 
     return ship

package/src/entities/slot-multiplier.ts

@@ -0,0 +1,21 @@
+import type {EntitySlot} from '../data/recipes-runtime'
+
+export const U16_MAX = 65535
+
+export interface InstalledModule {
+    slotIndex: number
+    itemId: number
+    stats: bigint
+}
+
+export function clampUint16(value: number): number {
+    return Math.min(value, U16_MAX)
+}
+
+export function applySlotMultiplier(value: number, outputPct: number): number {
+    return clampUint16(Math.floor((value * outputPct) / 100))
+}
+
+export function getSlotAmp(layout: EntitySlot[], slotIndex: number): number {
+    return layout[slotIndex]?.outputPct ?? 100
+}

package/src/entities/warehouse.ts

@@ -10,6 +10,8 @@ import type {PackedModuleInput} from './ship'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
 import {computeLoaderCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
 
 export interface WarehouseStateInput {
     id: UInt64Type
@@ -104,7 +106,10 @@ export class Warehouse extends ServerContract.Types.entity_info {
     }
 }
 
-export function computeWarehouseCapabilities(modules: {itemId: number; stats: bigint}[]): {
+export function computeWarehouseCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): {
     loaders?: {mass: number; thrust: number; quantity: number}
 } {
     const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
@@ -117,10 +122,14 @@ export function computeWarehouseCapabilities(modules: {itemId: number; stats: bi
         for (const m of loaderModules) {
             const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalQuantity += caps.quantity
         }
-        warehouse.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+        warehouse.loaders = {
+            mass: totalMass,
+            thrust: clampUint16(totalThrust),
+            quantity: totalQuantity,
+        }
     }
 
     return warehouse

package/src/index-module.ts

@@ -16,9 +16,11 @@ export {Ship} from './entities/ship'
 export type {ShipStateInput, PackedModuleInput} from './entities/ship'
 export {Warehouse, computeWarehouseCapabilities} from './entities/warehouse'
 export type {WarehouseStateInput} from './entities/warehouse'
+export {Extractor, computeExtractorCapabilities} from './entities/extractor'
+export type {ExtractorStateInput, ExtractorCapabilities} from './entities/extractor'
 export {Container} from './entities/container'
 export type {ContainerStateInput} from './entities/container'
-export {makeShip, makeWarehouse, makeContainer} from './entities/makers'
+export {makeShip, makeWarehouse, makeExtractor, makeContainer} from './entities/makers'
 
 export type movement_stats = ServerContract.Types.movement_stats
 export type energy_stats = ServerContract.Types.energy_stats
@@ -180,16 +182,29 @@ export type {
     ProjectionOptions,
 } from './scheduling/projection'
 
-export {predictTaskCargoEffects} from './scheduling/predict-cargo'
-export type {
-    PredictedCargoAddition,
-    PredictedCargoTarget,
-    TaskCargoEffect,
-} from './scheduling/predict-cargo'
+export {taskCargoChanges} from './scheduling/task-cargo'
+export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
 
 export * from './types/capabilities'
 export * from './types/entity'
-export {EntityClass, getEntityClass, getPackedEntityType} from './types/entity-traits'
+export {
+    EntityClass,
+    ENTITY_SHIP,
+    ENTITY_WAREHOUSE,
+    ENTITY_EXTRACTOR,
+    ENTITY_CONTAINER,
+    shipTraits,
+    warehouseTraits,
+    extractorTraits,
+    containerTraits,
+    getEntityClass,
+    getPackedEntityType,
+    getEntityTraits,
+    isShip,
+    isWarehouse,
+    isExtractor,
+    isContainer,
+} from './types/entity-traits'
 export * from './capabilities'
 
 export {
@@ -323,6 +338,8 @@ export {
     computeLoaderThrust,
     computeCrafterSpeed,
     computeCrafterDrain,
+    computeHaulerCapacity,
+    computeHaulerEfficiency,
     computeWarpRange,
 } from './nft/description'
 

package/src/managers/actions.ts

@@ -85,6 +85,13 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    refrshentity(entityType: NameType, entityId: UInt64Type): Action {
+        return this.server.action('refrshentity', {
+            entity_type: Name.from(entityType),
+            entity_id: UInt64.from(entityId),
+        })
+    }
+
     transfer(
         sourceType: EntityTypeName,
         sourceId: UInt64Type,

package/src/nft/description.ts

@@ -14,6 +14,7 @@ import {
     ITEM_CONTAINER_T2_PACKED,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
     ITEM_HAULER_T1,
@@ -71,6 +72,8 @@ export function entityDisplayName(itemId: number): string {
             return 'Ship'
         case ITEM_WAREHOUSE_T1_PACKED:
             return 'Warehouse'
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return 'Extractor'
         case ITEM_CONTAINER_T1_PACKED:
             return 'Container'
         case ITEM_CONTAINER_T2_PACKED:
@@ -187,6 +190,8 @@ export function buildEntityDescription(
         baseCapacity = computeBaseCapacityShip(hullStats)
     } else if (itemId === ITEM_WAREHOUSE_T1_PACKED) {
         baseCapacity = computeBaseCapacityWarehouse(hullStats)
+    } else if (itemId === ITEM_EXTRACTOR_T1_PACKED) {
+        baseCapacity = computeBaseCapacityShip(hullStats)
     }
 
     let out = entityDisplayName(itemId)

package/src/resolution/resolve-item.ts

@@ -39,6 +39,7 @@ import type {ServerContract} from '../contracts'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_SHIP_T1_PACKED,
     ITEM_WAREHOUSE_T1_PACKED,
 } from '../data/item-ids'
@@ -270,6 +271,8 @@ function hullCapsForEntity(
             return computeShipHullCapabilities(decoded)
         case ITEM_WAREHOUSE_T1_PACKED:
             return computeWarehouseHullCapabilities(decoded)
+        case ITEM_EXTRACTOR_T1_PACKED:
+            return computeShipHullCapabilities(decoded)
         case ITEM_CONTAINER_T1_PACKED:
             return computeContainerCapabilities(decoded)
         case ITEM_CONTAINER_T2_PACKED:

package/src/scheduling/task-cargo.ts

@@ -0,0 +1,47 @@
+import type {ServerContract} from '../contracts'
+import {TaskType} from '../types'
+
+export type TaskCargoDirection = 'in' | 'out'
+
+export interface TaskCargoChange {
+    direction: TaskCargoDirection
+    item_id: number
+    stats: bigint
+    modules: ServerContract.Types.module_entry[]
+    quantity: number
+}
+
+function toChange(
+    item: ServerContract.Types.cargo_item,
+    direction: TaskCargoDirection
+): TaskCargoChange {
+    return {
+        direction,
+        item_id: Number(item.item_id),
+        stats: BigInt(item.stats.toString()),
+        modules: item.modules ?? [],
+        quantity: Number(item.quantity),
+    }
+}
+
+export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChange[] {
+    const items = task.cargo ?? []
+    if (items.length === 0) return []
+    switch (Number(task.type)) {
+        case TaskType.LOAD:
+        case TaskType.UNWRAP:
+            return items.map((i) => toChange(i, 'in'))
+        case TaskType.GATHER:
+            return task.entitytarget ? [] : items.map((i) => toChange(i, 'in'))
+        case TaskType.UNLOAD:
+        case TaskType.WRAP:
+            return items.map((i) => toChange(i, 'out'))
+        case TaskType.CRAFT:
+            return [
+                ...items.slice(0, -1).map((i) => toChange(i, 'out')),
+                toChange(items[items.length - 1], 'in'),
+            ]
+        default:
+            return []
+    }
+}