@shipload/sdk 1.0.0-next.62 → 1.0.0-next.64

package/src/managers/construction.ts

@@ -4,7 +4,7 @@ import type {ServerContract} from '../contracts'
 import {PlotManager} from './plot'
 import {getItem} from '../data/catalog'
 import {calc_build_duration} from '../capabilities/crafting'
-import {getLanes, getTasks} from '../scheduling/schedule'
+import {getLanes, getTasks, isIdle} from '../scheduling/schedule'
 import {HoldKind, TaskType} from '../types'
 import type {
     BuildableTarget,
@@ -34,6 +34,16 @@ export class ConstructionManager extends BaseManager {
         return null
     }
 
+    canAbandon(
+        entity: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[]
+    ): boolean {
+        if (entity.kind.toString() !== 'plot') return false
+        if (!isIdle(entity)) return false
+        if (Number(entity.cargomass) !== 0) return false
+        return !cargo.some((c) => c.entity_id.equals(entity.id))
+    }
+
     eligibleSources(
         target: BuildableTarget,
         entities: ServerContract.Types.entity_info[],

package/src/managers/context.ts

@@ -11,7 +11,9 @@ import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
 import {ClusterManager} from './cluster'
 import {NftManager} from './nft'
+import {BalancesManager} from './balances'
 import {JobsManager} from './jobs'
+import {InfluenceManager} from './influence'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
@@ -23,7 +25,9 @@ export class GameContext {
     private _actions?: ActionsManager
     private _clusters?: ClusterManager
     private _nft?: NftManager
+    private _balances?: BalancesManager
     private _jobs?: JobsManager
+    private _influence?: InfluenceManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -93,6 +97,13 @@ export class GameContext {
         return this._nft
     }
 
+    get balances(): BalancesManager {
+        if (!this._balances) {
+            this._balances = new BalancesManager(this)
+        }
+        return this._balances
+    }
+
     get jobs(): JobsManager {
         if (!this._jobs) {
             this._jobs = new JobsManager(this)
@@ -100,6 +111,13 @@ export class GameContext {
         return this._jobs
     }
 
+    get influence(): InfluenceManager {
+        if (!this._influence) {
+            this._influence = new InfluenceManager(this)
+        }
+        return this._influence
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }

package/src/managers/entities.ts

@@ -55,6 +55,17 @@ export class EntitiesManager extends BaseManager {
         return result as ServerContract.Types.entity_summary[]
     }
 
+    async getDepot(
+        depotId: UInt64Type,
+        owner: NameType | ServerContract.Types.player_row
+    ): Promise<ServerContract.Types.depot_view> {
+        const result = await this.server.readonly('getdepot', {
+            depot_id: depotId,
+            owner: this.resolveOwner(owner),
+        })
+        return result as ServerContract.Types.depot_view
+    }
+
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner

package/src/managers/index.ts

@@ -11,8 +11,22 @@ export {ActionsManager} from './actions'
 export {ClusterManager, computeFreeCells} from './cluster'
 export type {GridCell, ClusterCell, Cluster} from './cluster'
 export {NftManager} from './nft'
-export type {NftConfigForItem} from './nft'
+export type {NftConfigForItem, WrapConfig, WrapGate} from './nft'
+export {BalancesManager} from './balances'
+export type {DepositConfig, PlatformBalance, TokenBalance} from './balances'
 export {JobsManager} from './jobs'
+export {InfluenceManager} from './influence'
+export type {
+    CharterProgress,
+    ContributePreview,
+    ContributePreviewRow,
+    FoundedWorld,
+    InfluenceStanding,
+    PendingBallot,
+    VoteCast,
+    VoteOption,
+    VoteStandings,
+} from './influence'
 export {PlotManager} from './plot'
 export type {PlotProgress, PlotProgressInputRow} from './plot'
 export {ConstructionManager} from './construction'

package/src/managers/influence.test.ts

@@ -0,0 +1,58 @@
+import {describe, expect, it} from 'bun:test'
+import {Name, UInt64} from '@wharfkit/antelope'
+import {InfluenceManager} from './influence'
+import {coordsToLocationId} from '../types'
+
+const LOCATION = {x: 12, y: 34}
+
+function managerWith(rowsByTable: Record<string, unknown[]>) {
+    const calls: {table: string; scope: unknown}[] = []
+    const table = (name: string, scope: unknown) => {
+        calls.push({table: name, scope})
+        return {all: async () => rowsByTable[name] ?? []}
+    }
+    const ctx = {server: {table}} as never
+    return {manager: new InfluenceManager(ctx), calls}
+}
+
+describe('InfluenceManager scoped table reads', () => {
+    it('getVoteCasts scopes infvote by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            infvote: [{account: Name.from('eggmaple.gm'), epoch: 5, node_id: 2, weight: '100'}],
+        })
+        const rows = await manager.getVoteCasts(LOCATION)
+        expect(calls).toHaveLength(1)
+        expect(calls[0].table).toBe('infvote')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([
+            {account: Name.from('eggmaple.gm'), epoch: 5, nodeId: 2, weight: 100n},
+        ])
+    })
+
+    it('getVoteTallies scopes inftally by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            inftally: [{node_id: 3, total: '250'}],
+        })
+        const rows = await manager.getVoteTallies(LOCATION)
+        expect(calls[0].table).toBe('inftally')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([{nodeId: 3, total: 250n}])
+    })
+
+    it('getBuiltCharters scopes charters by location and maps fields', async () => {
+        const {manager, calls} = managerWith({
+            charters: [{node_id: 1, entity_id: '9001'}],
+        })
+        const rows = await manager.getBuiltCharters(LOCATION)
+        expect(calls[0].table).toBe('charters')
+        expect(UInt64.from(calls[0].scope as never).equals(coordsToLocationId(LOCATION))).toBe(true)
+        expect(rows).toEqual([{nodeId: 1, entityId: 9001n}])
+    })
+
+    it('returns an empty array when the scope has no rows', async () => {
+        const {manager} = managerWith({})
+        expect(await manager.getVoteCasts(LOCATION)).toEqual([])
+        expect(await manager.getVoteTallies(LOCATION)).toEqual([])
+        expect(await manager.getBuiltCharters(LOCATION)).toEqual([])
+    })
+})

package/src/managers/influence.ts

@@ -0,0 +1,347 @@
+import {Int64, Name, type NameType, UInt64} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+import {coordsToLocationId, locationIdToCoords, type CoordinatesType} from '../types'
+import {
+    type BuiltCharter,
+    citizenryName,
+    contributeDuration,
+    decayActive,
+    deriveDemand,
+    pricingFromWeights,
+    valueCargoItem,
+    type DemandTriple,
+    type DemandView,
+    type ValuedItem,
+} from '../influence'
+import {getItem} from '../data/catalog'
+
+export interface InfluenceStanding {
+    epoch: number
+    playerLifetime: bigint
+    playerActive: bigint
+    standingLifetime: bigint
+    standingActive: bigint
+    locationLifetime: bigint
+    locationActive: bigint
+    watermark: bigint
+    mandate: number
+    founder: Name
+    founded: number
+}
+
+export interface CharterProgress {
+    locationId: bigint
+    lifetime: bigint
+    watermark: bigint
+    surplus: bigint
+    mandate: number
+    nextCost: bigint
+    prereqsMet: boolean
+    buildable: boolean
+    epoch: number
+    built: {nodeId: number; completedEpoch: number; entityId: bigint}[]
+}
+
+export interface ContributePreviewRow {
+    itemId: number
+    quantity: number
+    stats: bigint
+    valueAtomic: bigint
+    massKg: number
+}
+
+export interface ContributePreview {
+    rows: ContributePreviewRow[]
+    totalAtomic: bigint
+    totalMassKg: number
+    durationSeconds: number
+    demand: DemandView
+}
+
+export interface FoundedWorld {
+    locationId: bigint
+    x: number
+    y: number
+    lifetime: bigint
+    active: bigint
+    watermark: bigint
+    chosen: number
+    chosenEpoch: number
+    mandate: number | undefined
+    founder: Name
+    founded: number
+}
+
+export interface VoteOption {
+    nodeId: number
+    cost: bigint
+    eligible: boolean
+    total: bigint | undefined
+}
+
+export interface VoteStandings {
+    locationId: bigint
+    epoch: number
+    chosen: number
+    chosenEpoch: number
+    mandate: number
+    ballotEpoch: number | undefined
+    talliesSuppressed: boolean
+    options: VoteOption[]
+}
+
+export interface VoteCast {
+    account: Name
+    epoch: number
+    nodeId: number
+    weight: bigint
+}
+
+export interface PendingBallot {
+    locationId: bigint
+    x: number
+    y: number
+    epoch: number
+}
+
+function big(value: unknown): bigint {
+    return BigInt(String(value))
+}
+
+export class InfluenceManager extends BaseManager {
+    async getStanding(owner: NameType, location: CoordinatesType): Promise<InfluenceStanding> {
+        const result = (await this.server.readonly('getinfluence', {
+            owner: Name.from(owner),
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })) as ServerContract.Types.influence_totals
+
+        return {
+            epoch: Number(result.epoch),
+            playerLifetime: big(result.player_lifetime),
+            playerActive: big(result.player_active),
+            standingLifetime: big(result.standing_lifetime),
+            standingActive: big(result.standing_active),
+            locationLifetime: big(result.location_lifetime),
+            locationActive: big(result.location_active),
+            watermark: big(result.watermark),
+            mandate: Number(result.mandate),
+            founder: Name.from(result.founder),
+            founded: Number(result.founded),
+        }
+    }
+
+    async getDemandConfig(): Promise<DemandTriple> {
+        const row = (await this.server.table('infdemand').get()) as
+            | ServerContract.Types.infdemand_row
+            | undefined
+        if (!row) throw new Error('influence demand config is unset')
+        return {peak: big(row.peak), base: big(row.base), floor: big(row.floor)}
+    }
+
+    async getQualityDivisor(): Promise<number> {
+        const row = (await this.server.table('infquality').get()) as
+            | ServerContract.Types.infquality_row
+            | undefined
+        if (!row) throw new Error('influence quality config is unset')
+        return Number(row.d1)
+    }
+
+    async getWeights(): Promise<ServerContract.Types.infweight_row[]> {
+        return (await this.server.table('infweight').all()) as ServerContract.Types.infweight_row[]
+    }
+
+    async getDemand(location: CoordinatesType): Promise<DemandView> {
+        const game = await this.getGame()
+        const state = await this.getState()
+        const triple = await this.getDemandConfig()
+        return deriveDemand({
+            gameSeed: game.config.seed,
+            epochSeed: state.epochSeed,
+            coordinates: location,
+            triple,
+        })
+    }
+
+    async getCitizenryName(location: CoordinatesType): Promise<string | undefined> {
+        const game = await this.getGame()
+        return citizenryName(game.config.seed, location)
+    }
+
+    async previewContribution(
+        location: CoordinatesType,
+        bundle: ValuedItem[],
+        opts: {altitudeZ?: number} = {}
+    ): Promise<ContributePreview> {
+        const [demand, d1, weights] = await Promise.all([
+            this.getDemand(location),
+            this.getQualityDivisor(),
+            this.getWeights(),
+        ])
+        const pricing = pricingFromWeights(
+            d1,
+            weights.map((w) => ({
+                category: Number(w.category),
+                tier: Number(w.tier),
+                weightFp: big(w.weight_fp),
+            }))
+        )
+
+        let totalAtomic = 0n
+        let totalMassKg = 0
+        const rows = bundle.map((item) => {
+            const valueAtomic = valueCargoItem(item, demand, pricing)
+            const massKg = getItem(item.itemId).mass * item.quantity
+            totalAtomic += valueAtomic
+            totalMassKg += massKg
+            return {...item, valueAtomic, massKg}
+        })
+
+        return {
+            rows,
+            totalAtomic,
+            totalMassKg,
+            durationSeconds: contributeDuration(totalMassKg, opts.altitudeZ ?? 0),
+            demand,
+        }
+    }
+
+    async getCharter(location: CoordinatesType): Promise<CharterProgress> {
+        const result = (await this.server.readonly('getcharter', {
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })) as ServerContract.Types.charter_result
+
+        return {
+            locationId: big(result.location_id),
+            lifetime: big(result.lifetime),
+            watermark: big(result.watermark),
+            surplus: big(result.surplus),
+            mandate: Number(result.mandate),
+            nextCost: big(result.next_cost),
+            prereqsMet: Boolean(result.prereqs_met),
+            buildable: Boolean(result.buildable),
+            epoch: Number(result.epoch),
+            built: result.built.map((b) => ({
+                nodeId: Number(b.node_id),
+                completedEpoch: Number(b.completed_epoch),
+                entityId: big(b.entity_id),
+            })),
+        }
+    }
+
+    async getPools(): Promise<ServerContract.Types.pool_view[]> {
+        const result = (await this.server.readonly('getpools')) as ServerContract.Types.pools_result
+        return result.pools
+    }
+
+    async getPool(category: number, tier: number): Promise<ServerContract.Types.pool_pair_result> {
+        return (await this.server.readonly('getpool', {
+            category,
+            tier,
+        })) as ServerContract.Types.pool_pair_result
+    }
+
+    async getMintConfig(): Promise<ServerContract.Types.mintcfg_result> {
+        return (await this.server.readonly('getmintcfg')) as ServerContract.Types.mintcfg_result
+    }
+
+    async getVotes(location: CoordinatesType): Promise<VoteStandings> {
+        const result = (await this.server.readonly('getvotes', {
+            x: Int64.from(location.x),
+            y: Int64.from(location.y),
+        })) as ServerContract.Types.vote_result
+
+        const epoch = Number(result.epoch)
+        const rawBallotEpoch = Number(result.ballot_epoch)
+        const ballotEpoch = rawBallotEpoch === 0 ? undefined : rawBallotEpoch
+        const talliesSuppressed = ballotEpoch !== undefined && ballotEpoch < epoch
+
+        return {
+            locationId: big(result.location_id),
+            epoch,
+            chosen: Number(result.chosen),
+            chosenEpoch: Number(result.chosen_epoch),
+            mandate: Number(result.effective),
+            ballotEpoch,
+            talliesSuppressed,
+            options: result.options.map((option) => ({
+                nodeId: Number(option.node_id),
+                cost: big(option.cost),
+                eligible: Boolean(option.eligible),
+                total: talliesSuppressed ? undefined : big(option.total),
+            })),
+        }
+    }
+
+    async getVoteCasts(location: CoordinatesType): Promise<VoteCast[]> {
+        const rows = (await this.server
+            .table('infvote', coordsToLocationId(location))
+            .all()) as ServerContract.Types.infvote_row[]
+        return rows.map((row) => ({
+            account: Name.from(row.account),
+            epoch: Number(row.epoch),
+            nodeId: Number(row.node_id),
+            weight: big(row.weight),
+        }))
+    }
+
+    async getVoteTallies(location: CoordinatesType): Promise<{nodeId: number; total: bigint}[]> {
+        const rows = (await this.server
+            .table('inftally', coordsToLocationId(location))
+            .all()) as ServerContract.Types.inftally_row[]
+        return rows.map((row) => ({nodeId: Number(row.node_id), total: big(row.total)}))
+    }
+
+    async getBuiltCharters(location: CoordinatesType): Promise<BuiltCharter[]> {
+        const rows = (await this.server
+            .table('charters', coordsToLocationId(location))
+            .all()) as ServerContract.Types.charters_row[]
+        return rows.map((row) => ({nodeId: Number(row.node_id), entityId: big(row.entity_id)}))
+    }
+
+    async getBallotQueue(): Promise<PendingBallot[]> {
+        const rows = (await this.server
+            .table('infballot')
+            .all()) as ServerContract.Types.infballot_row[]
+        return rows.map((row) => ({
+            locationId: big(row.location_id),
+            ...locationIdToCoords(row.location_id),
+            epoch: Number(row.epoch),
+        }))
+    }
+
+    async getFoundedWorlds(opts: {withMandate?: boolean} = {}): Promise<FoundedWorld[]> {
+        const rows = (await this.server.table('infloc').all()) as ServerContract.Types.infloc_row[]
+        const epoch = (await this.getState()).epoch
+        const worlds = rows.map((row) => ({
+            locationId: big(row.location_id),
+            ...locationIdToCoords(row.location_id),
+            lifetime: big(row.lifetime),
+            active: decayActive(
+                big(row.active),
+                Math.max(0, Number(epoch) - Number(row.last_update_epoch))
+            ),
+            watermark: big(row.watermark),
+            chosen: Number(row.chosen),
+            chosenEpoch: Number(row.chosen_epoch),
+            mandate: undefined as number | undefined,
+            founder: Name.from(row.founder),
+            founded: Number(row.founded),
+        }))
+
+        if (!opts.withMandate) return worlds
+
+        for (const world of worlds) {
+            world.mandate = (await this.getCharter({x: world.x, y: world.y})).mandate
+        }
+        return worlds
+    }
+
+    async isFounded(location: CoordinatesType): Promise<boolean> {
+        const id = coordsToLocationId(location)
+        const row = await this.server.table('infloc').get(UInt64.from(id))
+        return row !== undefined
+    }
+}

package/src/managers/nft.test.ts

@@ -1,5 +1,5 @@
 import {describe, expect, test} from 'bun:test'
-import {resolveLockedAmount} from './nft'
+import {resolveLockedAmount, wrapCostKey} from './nft'
 
 describe('resolveLockedAmount', () => {
     test('no fee refunds the full cost', () => {
@@ -12,3 +12,10 @@ describe('resolveLockedAmount', () => {
         expect(resolveLockedAmount(101n, 250)).toBe(99n) // fee = floor(101*250/10000)=2
     })
 })
+
+describe('wrapCostKey', () => {
+    test('packs item type and tier as (type << 8) | tier', () => {
+        expect(wrapCostKey(0, 1).toString()).toBe('1')
+        expect(wrapCostKey(3, 2).toString()).toBe('770')
+    })
+})

package/src/managers/nft.ts

@@ -1,4 +1,4 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {Name, UInt64, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import type {PlatformContract, ServerContract} from '../contracts'
 
@@ -7,6 +7,17 @@ export interface NftConfigForItem {
     schemaName: string
 }
 
+export interface WrapConfig {
+    feePctBasisPoints: number
+    feeAccount: Name
+}
+
+export interface WrapGate {
+    owner: Name
+    game: Name
+    lastAssetId: UInt64
+}
+
 export interface WrapDeposit {
     cost: bigint
     refund: bigint
@@ -21,8 +32,13 @@ export function resolveLockedAmount(cost: bigint, feePctBasisPoints: number): bi
     return cost - fee
 }
 
+export function wrapCostKey(itemType: number, tier: number): UInt64 {
+    return UInt64.from((BigInt(itemType) << 8n) | BigInt(tier))
+}
+
 export class NftManager extends BaseManager {
     private cache = new Map<string, NftConfigForItem | null>()
+    private wrapConfig?: WrapConfig | null
 
     async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
         const id = UInt64.from(itemId)
@@ -40,31 +56,55 @@ export class NftManager extends BaseManager {
         return result ?? undefined
     }
 
-    async getWrapDeposit(itemType: number, tier: number): Promise<WrapDeposit | null> {
-        const key = UInt64.from((BigInt(itemType) << 8n) | BigInt(tier))
-        const costRow = (await this.server.table('wrapcost').get(key)) as
+    async getWrapConfig(reload = false): Promise<WrapConfig | null> {
+        if (!reload && this.wrapConfig !== undefined) {
+            return this.wrapConfig
+        }
+        const row = (await this.server.table('wrapconfig').get()) as
+            | ServerContract.Types.wrapconfig_row
+            | undefined
+        this.wrapConfig = row
+            ? {feePctBasisPoints: Number(row.fee_pct), feeAccount: row.fee_account}
+            : null
+        return this.wrapConfig
+    }
+
+    async getWrapCost(itemType: number, tier: number): Promise<bigint> {
+        const row = (await this.server.table('wrapcost').get(wrapCostKey(itemType, tier))) as
             | ServerContract.Types.wrapcost_row
             | undefined
-        const cost = costRow ? BigInt(costRow.amount.toString()) : 0n
+        return row ? BigInt(row.amount.toString()) : 0n
+    }
+
+    async getWrapDeposit(
+        itemType: number,
+        tier: number,
+        opts: {reload?: boolean} = {}
+    ): Promise<WrapDeposit | null> {
+        const cost = await this.getWrapCost(itemType, tier)
         if (cost === 0n) return null
 
-        const cfg = (await this.server.table('wrapconfig').get()) as
-            | ServerContract.Types.wrapconfig_row
-            | undefined
-        const feePctBasisPoints = cfg ? Number(cfg.fee_pct) : 0
+        const wrapConfig = await this.getWrapConfig(opts.reload)
+        const feePctBasisPoints = wrapConfig ? wrapConfig.feePctBasisPoints : 0
 
-        const depositCfg = (await this.platform.table('depositcfg').get()) as
-            | PlatformContract.Types.depositcfg_row
-            | undefined
-        if (!depositCfg) return null
+        const depositConfig = await this.context.balances.getDepositConfig(opts.reload)
+        if (!depositConfig) return null
 
         return {
             cost,
             refund: resolveLockedAmount(cost, feePctBasisPoints),
             feePct: feePctBasisPoints / 100,
-            symbol: depositCfg.token_symbol.code.toString(),
-            precision: depositCfg.token_symbol.precision,
-            tokenContract: depositCfg.token_contract.toString(),
+            symbol: depositConfig.symbol.code.toString(),
+            precision: depositConfig.symbol.precision,
+            tokenContract: depositConfig.tokenContract.toString(),
         }
     }
+
+    async getWrapGate(owner: NameType): Promise<WrapGate | null> {
+        const row = (await this.platform.table('wrapgate').get(Name.from(owner))) as
+            | PlatformContract.Types.wrapgate_row
+            | undefined
+        if (!row) return null
+        return {owner: row.owner, game: row.game, lastAssetId: row.last_asset_id}
+    }
 }

package/src/nft/description.ts

@@ -85,6 +85,11 @@ export function computeBaseCapacityWorkshop(stats: bigint): number {
     return Math.floor(5_000_000 * 6 ** (s / 1998))
 }
 
+export function computeBaseCapacityDepot(stats: bigint): number {
+    const s = decodeStat(stats, 0) + decodeStat(stats, 2)
+    return Math.floor(50_000_000 * 6 ** (s / 1998))
+}
+
 const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
     ship: computeBaseCapacityShip,
     warehouse: computeBaseCapacityWarehouse,
@@ -95,6 +100,8 @@ const CAPACITY_FN_BY_KIND: Record<string, (stats: bigint) => number> = {
     mdriver: computeBaseCapacityContainer,
     mcatcher: computeBaseCapacityContainer,
     container: computeBaseCapacityContainer,
+    nexus: computeBaseCapacityContainer,
+    depot: computeBaseCapacityDepot,
 }
 
 export function computeBaseCapacityForEntity(itemId: number, stats: bigint): number {

package/src/scheduling/task-cargo.ts

@@ -34,6 +34,7 @@ export function taskCargoChanges(task: ServerContract.Types.task): TaskCargoChan
         case TaskType.GATHER:
             return task.couplings.length > 0 ? [] : items.map((i) => toChange(i, 'in'))
         case TaskType.UNLOAD:
+        case TaskType.CONTRIBUTE:
             return items.map((i) => toChange(i, 'out'))
         case TaskType.CRAFT:
             return [