@shipload/sdk 1.0.0-next.1 → 1.0.0-next.11

package/src/managers/entities.ts

@@ -3,14 +3,18 @@ import {BaseManager} from './base'
 import {Ship} from '../entities/ship'
 import {Warehouse} from '../entities/warehouse'
 import {Container} from '../entities/container'
+import {Extractor} from '../entities/extractor'
+import {Factory} from '../entities/factory'
+import {Nexus} from '../entities/nexus'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
+export type EntityType = 'ship' | 'warehouse' | 'extractor' | 'factory' | 'container' | 'nexus'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
+    async getEntity(
+        id: UInt64Type
+    ): Promise<Ship | Warehouse | Extractor | Factory | Container | Nexus> {
         const result = await this.server.readonly('getentity', {
-            entity_type: Name.from(type),
             entity_id: id,
         })
         const entityInfo = result as ServerContract.Types.entity_info
@@ -20,11 +24,11 @@ export class EntitiesManager extends BaseManager {
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
         type?: EntityType
-    ): Promise<(Ship | Warehouse | Container)[]> {
+    ): Promise<(Ship | Warehouse | Extractor | Factory | Container | Nexus)[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: type,
         })
         const entities = result as ServerContract.Types.entity_info[]
         return entities.map((entity) => this.wrapEntity(entity))
@@ -37,21 +41,29 @@ export class EntitiesManager extends BaseManager {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getsummaries', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: type,
         })
         return result as ServerContract.Types.entity_summary[]
     }
 
     async getShip(id: UInt64Type): Promise<Ship> {
-        return (await this.getEntity('ship', id)) as Ship
+        return (await this.getEntity(id)) as Ship
     }
 
     async getWarehouse(id: UInt64Type): Promise<Warehouse> {
-        return (await this.getEntity('warehouse', id)) as Warehouse
+        return (await this.getEntity(id)) as Warehouse
     }
 
     async getContainer(id: UInt64Type): Promise<Container> {
-        return (await this.getEntity('container', id)) as Container
+        return (await this.getEntity(id)) as Container
+    }
+
+    async getExtractor(id: UInt64Type): Promise<Extractor> {
+        return (await this.getEntity(id)) as Extractor
+    }
+
+    async getFactory(id: UInt64Type): Promise<Factory> {
+        return (await this.getEntity(id)) as Factory
     }
 
     async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
@@ -66,6 +78,14 @@ export class EntitiesManager extends BaseManager {
         return (await this.getEntities(owner, 'container')) as Container[]
     }
 
+    async getExtractors(owner: NameType | ServerContract.Types.player_row): Promise<Extractor[]> {
+        return (await this.getEntities(owner, 'extractor')) as Extractor[]
+    }
+
+    async getFactories(owner: NameType | ServerContract.Types.player_row): Promise<Factory[]> {
+        return (await this.getEntities(owner, 'factory')) as Factory[]
+    }
+
     async getShipSummaries(
         owner: NameType | ServerContract.Types.player_row
     ): Promise<ServerContract.Types.entity_summary[]> {
@@ -84,14 +104,42 @@ export class EntitiesManager extends BaseManager {
         return this.getSummaries(owner, 'container')
     }
 
-    private wrapEntity(entity: ServerContract.Types.entity_info): Ship | Warehouse | Container {
-        if (entity.type.equals('ship')) {
-            return new Ship(entity)
-        } else if (entity.type.equals('warehouse')) {
-            return new Warehouse(entity)
-        } else {
-            return new Container(entity)
-        }
+    async getExtractorSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'extractor')
+    }
+
+    async getFactorySummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'factory')
+    }
+
+    async getNexus(id: UInt64Type): Promise<Nexus> {
+        return (await this.getEntity(id)) as Nexus
+    }
+
+    async getNexuses(owner: NameType | ServerContract.Types.player_row): Promise<Nexus[]> {
+        return (await this.getEntities(owner, 'nexus')) as Nexus[]
+    }
+
+    async getNexusSummaries(
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.entity_summary[]> {
+        return this.getSummaries(owner, 'nexus')
+    }
+
+    private wrapEntity(
+        entity: ServerContract.Types.entity_info
+    ): Ship | Warehouse | Extractor | Factory | Container | Nexus {
+        if (entity.type.equals('ship')) return new Ship(entity)
+        if (entity.type.equals('warehouse')) return new Warehouse(entity)
+        if (entity.type.equals('extractor')) return new Extractor(entity)
+        if (entity.type.equals('factory')) return new Factory(entity)
+        if (entity.type.equals('container')) return new Container(entity)
+        if (entity.type.equals('nexus')) return new Nexus(entity)
+        throw new Error(`unknown entity type: ${entity.type}`)
     }
 
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {

package/src/managers/locations.ts

@@ -1,6 +1,6 @@
-import {type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import type {UInt16Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, coordsToLocationId, type Distance} from '../types'
+import type {CoordinatesType, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 import type {ServerContract} from '../contracts'
@@ -47,22 +47,4 @@ export class LocationsManager extends BaseManager {
             reserve: overrideMap.get(s.index) ?? s.reserve,
         }))
     }
-
-    async getLocationEntity(
-        id: UInt64Type
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const row = await this.server.table('location').get(UInt64.from(id))
-        return row ?? undefined
-    }
-
-    async getLocationEntityAt(
-        coords: CoordinatesType
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const id = coordsToLocationId(coords)
-        return this.getLocationEntity(id)
-    }
-
-    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
-        return this.server.table('location').all()
-    }
 }

package/src/nft/atomicdata.ts

@@ -0,0 +1,128 @@
+export interface SchemaField {
+    name: string
+    type: string
+}
+
+export type RawData =
+    | Uint8Array
+    | string
+    | number[]
+    | {immutable_serialized_data: Uint8Array | string | number[]}
+
+export function deserializeAtomicData(
+    data: RawData,
+    schema: SchemaField[]
+): Record<string, unknown> {
+    let rawData: Uint8Array | string | number[]
+    if (data && typeof data === 'object' && 'immutable_serialized_data' in (data as object)) {
+        rawData = (data as {immutable_serialized_data: Uint8Array | string | number[]})
+            .immutable_serialized_data
+    } else {
+        rawData = data as Uint8Array | string | number[]
+    }
+
+    let bytes: Uint8Array
+    if (typeof rawData === 'string') {
+        const hex = rawData
+        bytes = new Uint8Array(hex.length / 2)
+        for (let i = 0; i < hex.length; i += 2) {
+            bytes[i / 2] = parseInt(hex.substring(i, i + 2), 16)
+        }
+    } else if (Array.isArray(rawData)) {
+        bytes = new Uint8Array(rawData)
+    } else {
+        bytes = rawData
+    }
+
+    let offset = 0
+
+    function readVarint(): number {
+        let result = 0
+        let multiplier = 1
+        while (bytes[offset] >= 128) {
+            result += (bytes[offset] - 128) * multiplier
+            offset++
+            multiplier *= 128
+        }
+        result += bytes[offset] * multiplier
+        offset++
+        return result
+    }
+
+    function readVarint64(): bigint {
+        let result = 0n
+        let multiplier = 1n
+        while (bytes[offset] >= 128) {
+            result += BigInt(bytes[offset] - 128) * multiplier
+            offset++
+            multiplier *= 128n
+        }
+        result += BigInt(bytes[offset]) * multiplier
+        offset++
+        return result
+    }
+
+    function readZigzagInt64(): bigint {
+        const unsigned = readVarint64()
+        if (unsigned % 2n === 0n) {
+            return unsigned / 2n
+        } else {
+            return -(unsigned / 2n) - 1n
+        }
+    }
+
+    function readString(): string {
+        const length = readVarint()
+        const str = new TextDecoder().decode(bytes.slice(offset, offset + length))
+        offset += length
+        return str
+    }
+
+    const RESERVED = 4
+    const result: Record<string, unknown> = {}
+
+    while (offset < bytes.length) {
+        const fieldIndex = readVarint() - RESERVED
+        const field = schema[fieldIndex]
+        if (!field) break
+
+        switch (field.type) {
+            case 'uint16':
+                result[field.name] = readVarint()
+                break
+            case 'uint32':
+                result[field.name] = readVarint()
+                break
+            case 'uint64':
+                result[field.name] = readVarint64()
+                break
+            case 'int32':
+                result[field.name] = readZigzagInt64()
+                break
+            case 'int64':
+                result[field.name] = readZigzagInt64()
+                break
+            case 'string':
+                result[field.name] = readString()
+                break
+            case 'uint16[]': {
+                const len = readVarint()
+                const arr: number[] = []
+                for (let i = 0; i < len; i++) arr.push(readVarint())
+                result[field.name] = arr
+                break
+            }
+            case 'uint64[]': {
+                const len = readVarint()
+                const arr: bigint[] = []
+                for (let i = 0; i < len; i++) arr.push(readVarint64())
+                result[field.name] = arr
+                break
+            }
+            default:
+                throw new Error(`Unknown type: ${field.type}`)
+        }
+    }
+
+    return result
+}

package/src/nft/description.ts

@@ -4,22 +4,29 @@ import {
     MODULE_ENGINE,
     MODULE_GATHERER,
     MODULE_GENERATOR,
+    MODULE_HAULER,
     MODULE_LOADER,
     MODULE_STORAGE,
+    MODULE_WARP,
 } from '../capabilities/modules'
 import {
     ITEM_CONTAINER_T1_PACKED,
     ITEM_CONTAINER_T2_PACKED,
     ITEM_CRAFTER_T1,
     ITEM_ENGINE_T1,
+    ITEM_EXTRACTOR_T1_PACKED,
     ITEM_GATHERER_T1,
     ITEM_GENERATOR_T1,
+    ITEM_HAULER_T1,
     ITEM_LOADER_T1,
     ITEM_SHIP_T1_PACKED,
     ITEM_STORAGE_T1,
     ITEM_WAREHOUSE_T1_PACKED,
+    ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
+import {gathererDepthForTier} from '../entities/ship-deploy'
+import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {
     return Math.floor(a / b)
@@ -27,7 +34,7 @@ function idiv(a: number, b: number): number {
 
 export function computeBaseHullmass(stats: bigint): number {
     const density = decodeStat(stats, 1)
-    return 25000 + 75 * density
+    return 100000 - 75 * density
 }
 
 export function computeBaseCapacityShip(stats: bigint): number {
@@ -42,17 +49,22 @@ export function computeBaseCapacityWarehouse(stats: bigint): number {
 
 export const computeEngineThrust = (vol: number): number => 400 + idiv(vol * 3, 4)
 export const computeEngineDrain = (thm: number): number => Math.max(30, 50 - idiv(thm, 70))
-export const computeGeneratorCap = (res: number): number => 300 + idiv(res, 6)
-export const computeGeneratorRech = (ref: number): number => 1 + idiv(ref * 3, 1000)
+export const computeGeneratorCap = (com: number): number => 300 + idiv(com, 6)
+export const computeGeneratorRech = (fin: number): number => 1 + idiv(fin * 3, 1000)
 export const computeGathererYield = (str: number): number => 200 + str
 export const computeGathererDrain = (con: number): number =>
     Math.max(250, 1250 - idiv(con * 25, 20))
-export const computeGathererDepth = (tol: number): number => 200 + idiv(tol * 3, 2)
+export const computeGathererDepth = (tol: number, tier: number): number =>
+    gathererDepthForTier(tol, tier)
 export const computeGathererSpeed = (ref: number): number => 100 + idiv(ref * 4, 5)
-export const computeLoaderMass = (fin: number): number => Math.max(200, 2000 - fin * 2)
+export const computeLoaderMass = (ins: number): number => Math.max(200, 2000 - ins * 2)
 export const computeLoaderThrust = (pla: number): number => 1 + idiv(pla, 500)
 export const computeCrafterSpeed = (rea: number): number => 100 + idiv(rea * 4, 5)
-export const computeCrafterDrain = (com: number): number => Math.max(5, 30 - idiv(com, 33))
+export const computeCrafterDrain = (fin: number): number => Math.max(5, 30 - idiv(fin, 33))
+export const computeHaulerCapacity = (fin: number): number => Math.max(1, 1 + idiv(fin, 400))
+export const computeHaulerEfficiency = (con: number): number => 2000 + con * 6
+export const computeHaulerDrain = (com: number): number => Math.max(3, 15 - idiv(com, 80))
+export const computeWarpRange = (stat: number): number => 100 + stat * 3
 
 export function entityDisplayName(itemId: number): string {
     switch (itemId) {
@@ -60,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:
@@ -83,6 +97,10 @@ export function moduleDisplayName(itemId: number): string {
             return 'Crafter'
         case ITEM_STORAGE_T1:
             return 'Storage'
+        case ITEM_HAULER_T1:
+            return 'Hauler'
+        case ITEM_WARP_T1:
+            return 'Warp'
         default:
             return 'Module'
     }
@@ -116,8 +134,10 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             const tol = decodeStat(stats, 1)
             const con = decodeStat(stats, 3)
             const ref = decodeStat(stats, 4)
+            const tier = getItem(itemId).tier
             out += `  Yield ${computeGathererYield(str)}  Depth ${computeGathererDepth(
-                tol
+                tol,
+                tier
             )}  Speed ${computeGathererSpeed(ref)}  Drain ${computeGathererDrain(con)}`
             break
         }
@@ -142,6 +162,18 @@ export function formatModuleLine(slot: number, itemId: number, stats: bigint): s
             out += `  +${pct}% capacity`
             break
         }
+        case MODULE_HAULER: {
+            const fin = decodeStat(stats, 0)
+            const con = decodeStat(stats, 1)
+            const com = decodeStat(stats, 2)
+            out += `  Capacity ${computeHaulerCapacity(fin)}  Efficiency ${computeHaulerEfficiency(con)}  Drain ${computeHaulerDrain(com)}`
+            break
+        }
+        case MODULE_WARP: {
+            const stat = decodeStat(stats, 0)
+            out += `  Range ${computeWarpRange(stat)}`
+            break
+        }
     }
     return out
 }
@@ -158,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/nft/index.ts

@@ -1,2 +1,3 @@
 export * from './deserializers'
 export * from './description'
+export * from './atomicdata'

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'
@@ -155,7 +156,8 @@ function resolveComponent(id: number, stats?: UInt64Type): ResolvedItem {
 
 function computeCapabilityGroup(
     moduleType: number,
-    stats: Record<string, number>
+    stats: Record<string, number>,
+    tier: number
 ): ResolvedAttributeGroup | undefined {
     switch (moduleType) {
         case MODULE_ENGINE: {
@@ -179,7 +181,7 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_GATHERER: {
-            const caps = computeGathererCapabilities(stats)
+            const caps = computeGathererCapabilities(stats, tier)
             return {
                 capability: 'Gatherer',
                 attributes: [
@@ -223,10 +225,11 @@ function computeCapabilityGroup(
             }
         }
         case MODULE_STORAGE: {
-            const str = stats.strength ?? 500
-            const hrd = stats.hardness ?? 500
-            const sat = stats.saturation ?? 500
-            const statSum = str + hrd + sat
+            const str = stats.strength
+            const den = stats.density
+            const hrd = stats.hardness
+            const sat = stats.saturation
+            const statSum = str + den + hrd + sat
             const pct = 10 + Math.floor((statSum * 10) / 2997)
             return {capability: 'Storage', attributes: [{label: 'Capacity Bonus', value: pct}]}
         }
@@ -241,7 +244,7 @@ function resolveModule(id: number, stats?: UInt64Type): ResolvedItem {
     if (stats !== undefined) {
         const decoded = decodeCraftedItemStats(id, toBigStats(stats))
         const modType = getModuleCapabilityType(id)
-        const group = computeCapabilityGroup(modType, decoded)
+        const group = computeCapabilityGroup(modType, decoded, item.tier)
         if (group) attributes = [group]
     }
     return {
@@ -268,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:
@@ -310,13 +315,16 @@ function resolveEntity(
                 const modStats = BigInt(mod.installed.stats.toString())
                 const decodedStats = decodeCraftedItemStats(modItemId, modStats)
                 const modType = getModuleCapabilityType(modItemId)
-                const group = computeCapabilityGroup(modType, decodedStats)
                 let modName = 'Module'
+                let modTier = 1
                 try {
-                    modName = getItem(modItemId).name
+                    const modItem = getItem(modItemId)
+                    modName = modItem.name
+                    modTier = modItem.tier
                 } catch {
                     modName = itemMetadata[modItemId]?.name ?? 'Module'
                 }
+                const group = computeCapabilityGroup(modType, decodedStats, modTier)
                 return {
                     name: modName,
                     installed: true,

package/src/scheduling/accessor.ts

@@ -72,6 +72,10 @@ export class ScheduleAccessor {
         return schedule.currentTaskProgress(this.entity, now)
     }
 
+    currentTaskProgressFloat(now: Date): number {
+        return schedule.currentTaskProgressFloat(this.entity, now)
+    }
+
     progress(now: Date): number {
         return schedule.scheduleProgress(this.entity, now)
     }

package/src/scheduling/projection.ts

@@ -14,7 +14,7 @@ import {
     RECIPE_INPUTS_INSUFFICIENT,
     RECIPE_INPUTS_INVALID,
     RECIPE_NOT_FOUND,
-    SHIP_CARGO_NOT_LOADED,
+    ENTITY_CARGO_NOT_LOADED,
 } from '../errors'
 import {getRecipe, type RecipeInput} from '../data/recipes-runtime'
 import {getItem} from '../data/catalog'
@@ -267,6 +267,10 @@ function applyTask(projected: ProjectedEntity, task: ServerContract.Types.task):
         case TaskType.DEPLOY:
             applyDeployTask(projected, task)
             break
+        case TaskType.UNDEPLOY:
+        case TaskType.WRAP_ENTITY:
+        case TaskType.DEMOLISH:
+            break
     }
 }
 
@@ -385,7 +389,7 @@ function validateCraftTask(task: ServerContract.Types.task, projected: Projected
                 break
             }
         }
-        if (!found) throw new Error(SHIP_CARGO_NOT_LOADED)
+        if (!found) throw new Error(ENTITY_CARGO_NOT_LOADED)
     }
 }
 
@@ -448,6 +452,10 @@ export function projectEntityAt(entity: Projectable, now: Date): ProjectedEntity
             case TaskType.DEPLOY:
                 if (taskComplete) applyDeployTask(projected, task)
                 break
+            case TaskType.UNDEPLOY:
+            case TaskType.WRAP_ENTITY:
+            case TaskType.DEMOLISH:
+                break
         }
     }
 

package/src/scheduling/schedule.ts

@@ -77,7 +77,7 @@ export function currentTaskIndex(entity: ScheduleData, now: Date): number {
         timeAccum += taskDuration
     }
 
-    return entity.schedule.tasks.length - 1
+    return -1
 }
 
 export function currentTask(entity: ScheduleData, now: Date): Task | undefined {
@@ -147,6 +147,20 @@ export function currentTaskProgress(entity: ScheduleData, now: Date): number {
     return Math.min(1, elapsed / duration)
 }
 
+export function currentTaskProgressFloat(entity: ScheduleData, now: Date): number {
+    if (!entity.schedule || entity.schedule.tasks.length === 0) return 0
+    const index = currentTaskIndex(entity, now)
+    if (index < 0) return 0
+    const task = entity.schedule.tasks[index]
+    const durationMs = task.duration.toNumber() * 1000
+    if (durationMs === 0) return 1
+    const startedMs = entity.schedule.started.toDate().getTime()
+    const taskStartMs = startedMs + getTaskStartTime(entity, index) * 1000
+    const elapsedMs = now.getTime() - taskStartMs
+    if (elapsedMs <= 0) return 0
+    return Math.min(1, elapsedMs / durationMs)
+}
+
 export function scheduleProgress(entity: ScheduleData, now: Date): number {
     const duration = scheduleDuration(entity)
     if (duration === 0) return hasSchedule(entity) ? 1 : 0

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 []
+    }
+}