@shipload/sdk 1.0.0-next.24 → 1.0.0-next.26

package/src/managers/actions.ts

@@ -17,6 +17,7 @@ import {
 import {BaseManager} from './base'
 import type {CoordinatesType} from '../types'
 import {ServerContract} from '../contracts'
+import {ATOMICASSETS_ABI, SHIPLOAD_COLLECTION} from '../nft/atomicassets'
 
 export type EntityRefInput = {
     entityType: NameType
@@ -206,14 +207,27 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    swapmodule(
+        entityId: UInt64Type,
+        moduleIndex: number,
+        moduleRef: ServerContract.ActionParams.Type.cargo_ref
+    ): Action {
+        return this.server.action('swapmodule', {
+            entity_id: UInt64.from(entityId),
+            module_index: moduleIndex,
+            module_ref: moduleRef,
+        })
+    }
+
     async wrap(
         owner: NameType,
         entityId: UInt64Type,
         nexusId: UInt64Type,
         cargoId: UInt64Type,
-        quantity: UInt64Type
+        quantity: UInt64Type,
+        opts: {claimRam?: boolean} = {}
     ): Promise<Action[]> {
-        return [
+        const actions: Action[] = [
             this.platform.action('wrapcargo', {
                 game: this.server.account,
                 owner: Name.from(owner),
@@ -223,6 +237,12 @@ export class ActionsManager extends BaseManager {
                 quantity: UInt64.from(quantity),
             }),
         ]
+        const claimRam =
+            opts.claimRam ?? (this.atomicAssetsAccount ?? 'atomicassets') !== 'atomicassets'
+        if (claimRam) {
+            actions.push(this.setLastPayer(owner, SHIPLOAD_COLLECTION))
+        }
+        return actions
     }
 
     undeploy(hostId: UInt64Type, targetId: UInt64Type): Action {
@@ -232,12 +252,19 @@ export class ActionsManager extends BaseManager {
         })
     }
 
+    claimStarter(owner: NameType): Action {
+        return this.server.action('claimstarter', {
+            owner: Name.from(owner),
+        })
+    }
+
     async wrapEntity(
         owner: NameType,
         entityId: UInt64Type,
-        nexusId: UInt64Type
+        nexusId: UInt64Type,
+        opts: {claimRam?: boolean} = {}
     ): Promise<Action[]> {
-        return [
+        const actions: Action[] = [
             this.platform.action('wrapentity', {
                 game: this.server.account,
                 owner: Name.from(owner),
@@ -245,6 +272,12 @@ export class ActionsManager extends BaseManager {
                 nexus_id: UInt64.from(nexusId),
             }),
         ]
+        const claimRam =
+            opts.claimRam ?? (this.atomicAssetsAccount ?? 'atomicassets') !== 'atomicassets'
+        if (claimRam) {
+            actions.push(this.setLastPayer(owner, SHIPLOAD_COLLECTION))
+        }
+        return actions
     }
 
     placecargo(owner: NameType, hostId: UInt64Type, assetId: UInt64Type): Action {
@@ -264,17 +297,20 @@ export class ActionsManager extends BaseManager {
     }
 
     transferForUnwrap(owner: NameType, assetId: UInt64Type): Action {
-        return Action.from({
-            account: 'atomicassets',
-            name: 'transfer',
-            authorization: [{actor: Name.from(owner), permission: 'active'}],
-            data: {
-                from: Name.from(owner),
-                to: this.platform.account,
-                asset_ids: [UInt64.from(assetId)],
-                memo: 'unwrap',
+        return Action.from(
+            {
+                account: this.atomicAssetsAccount,
+                name: 'transfer',
+                authorization: [{actor: Name.from(owner), permission: 'active'}],
+                data: {
+                    from: Name.from(owner),
+                    to: this.platform.account,
+                    asset_ids: [UInt64.from(assetId)],
+                    memo: 'unwrap',
+                },
             },
-        })
+            ATOMICASSETS_ABI
+        )
     }
 
     // Two top-level actions the wallet signs to unwrap an NFT into a host's cargo.
@@ -291,12 +327,27 @@ export class ActionsManager extends BaseManager {
     }
 
     setRamPayer(newPayer: NameType, assetId: UInt64Type): Action {
-        return Action.from({
-            account: 'atomicassets',
-            name: 'setrampayer',
-            authorization: [{actor: Name.from(newPayer), permission: 'active'}],
-            data: {new_payer: Name.from(newPayer), asset_id: UInt64.from(assetId)},
-        })
+        return Action.from(
+            {
+                account: this.atomicAssetsAccount,
+                name: 'setrampayer',
+                authorization: [{actor: Name.from(newPayer), permission: 'active'}],
+                data: {new_payer: Name.from(newPayer), asset_id: UInt64.from(assetId)},
+            },
+            ATOMICASSETS_ABI
+        )
+    }
+
+    setLastPayer(owner: NameType, collectionName: NameType): Action {
+        return Action.from(
+            {
+                account: this.atomicAssetsAccount,
+                name: 'setlastpayer',
+                authorization: [{actor: Name.from(owner), permission: 'active'}],
+                data: {owner: Name.from(owner), collection_name: Name.from(collectionName)},
+            },
+            ATOMICASSETS_ABI
+        )
     }
 
     demolish(entityId: UInt64Type): Action {

package/src/managers/base.ts

@@ -15,6 +15,10 @@ export abstract class BaseManager {
         return this.context.platform
     }
 
+    protected get atomicAssetsAccount() {
+        return this.context.atomicAssetsAccount
+    }
+
     protected async getGame() {
         return this.context.getGame()
     }

package/src/managers/construction-types.ts

@@ -4,7 +4,7 @@ import type {Item} from '../types'
 import type {Recipe} from '../data/recipes-runtime'
 import type {PlotProgress} from './plot'
 
-export type BuildState = 'initializing' | 'accepting' | 'ready' | 'finalizing'
+export type BuildState = 'initializing' | 'accepting' | 'ready' | 'scheduled' | 'finalizing'
 
 export type FinalizerCapability = 'crafter'
 
@@ -20,6 +20,7 @@ export interface BuildableTarget {
     finalizeAction: Name
     finalizerCapability: FinalizerCapability
     activeTask?: ServerContract.Types.task
+    scheduledBuild?: ScheduledBuild
 }
 
 export interface SourceEntityRef {
@@ -60,6 +61,16 @@ export interface InboundTransfer {
     etaSeconds: number
 }
 
+export interface ScheduledBuild {
+    shipId: UInt64
+    shipName: string
+    hasStarted: boolean
+    startsAt: number
+    completesAt: number
+    cancelable: boolean
+    blockingTaskCount: number
+}
+
 export interface Reservation {
     targetEntityId: UInt64
     targetEntityType: Name

package/src/managers/construction.ts

@@ -10,6 +10,7 @@ import type {
     FinalizerEntityRef,
     InboundTransfer,
     Reservation,
+    ScheduledBuild,
     SourceCargoStack,
     SourceEntityRef,
 } from './construction-types'
@@ -22,11 +23,12 @@ export class ConstructionManager extends BaseManager {
     getTarget(
         entity: ServerContract.Types.entity_row,
         cargo: ServerContract.Types.cargo_row[],
-        activeTask?: ServerContract.Types.task
+        activeTask?: ServerContract.Types.task,
+        scheduledBuild?: ScheduledBuild
     ): BuildableTarget | null {
         const kind = entity.kind.toString()
         if (kind === 'plot') {
-            return this.plot.buildableTarget(entity, cargo, activeTask)
+            return this.plot.buildableTarget(entity, cargo, activeTask, scheduledBuild)
         }
         return null
     }
@@ -140,6 +142,107 @@ export class ConstructionManager extends BaseManager {
         return out
     }
 
+    private plotReservation(
+        plot: ServerContract.Types.entity_info,
+        now: Date
+    ): {
+        builderId: UInt64
+        group?: UInt64
+        startsAt: number
+        completesAt: number
+        hasStarted: boolean
+    } | null {
+        const schedule = plot.schedule
+        if (!schedule) return null
+        const tasks = schedule.tasks
+        const startedMs = schedule.started.toDate().getTime()
+        let startSec = 0
+        for (const task of tasks) {
+            if (task.type.toNumber() === TaskType.RESERVED) {
+                if (!task.entitytarget) return null
+                const startsAt = startedMs + startSec * 1000
+                const completesAt = startsAt + task.duration.toNumber() * 1000
+                return {
+                    builderId: task.entitytarget.entity_id,
+                    group: task.entitygroup ?? undefined,
+                    startsAt,
+                    completesAt,
+                    hasStarted: startsAt <= now.getTime(),
+                }
+            }
+            startSec += task.duration.toNumber()
+        }
+        return null
+    }
+
+    private builderCancelability(
+        builder: ServerContract.Types.entity_info | undefined,
+        group: UInt64 | undefined
+    ): {cancelable: boolean; blockingTaskCount: number} {
+        if (!builder?.schedule || group === undefined) {
+            return {cancelable: false, blockingTaskCount: 0}
+        }
+        const tasks = builder.schedule.tasks
+        const buildIdx = tasks.findIndex(
+            (t) =>
+                t.type.toNumber() === TaskType.BUILDPLOT &&
+                t.entitygroup !== undefined &&
+                t.entitygroup.equals(group)
+        )
+        if (buildIdx < 0) return {cancelable: false, blockingTaskCount: 0}
+        const trailing = tasks.length - 1 - buildIdx
+        return {cancelable: trailing === 0, blockingTaskCount: trailing}
+    }
+
+    private buildFromReservation(
+        res: {
+            builderId: UInt64
+            group?: UInt64
+            startsAt: number
+            completesAt: number
+            hasStarted: boolean
+        },
+        builder: ServerContract.Types.entity_info | undefined
+    ): ScheduledBuild {
+        const {cancelable, blockingTaskCount} = this.builderCancelability(builder, res.group)
+        return {
+            shipId: res.builderId,
+            shipName: builder?.entity_name || res.builderId.toString(),
+            hasStarted: res.hasStarted,
+            startsAt: res.startsAt,
+            completesAt: res.completesAt,
+            cancelable,
+            blockingTaskCount,
+        }
+    }
+
+    scheduledBuildFor(
+        plot: ServerContract.Types.entity_info,
+        entities: ServerContract.Types.entity_info[],
+        now: Date
+    ): ScheduledBuild | null {
+        const res = this.plotReservation(plot, now)
+        if (!res) return null
+        const builder = entities.find((e) => e.id.equals(res.builderId))
+        return this.buildFromReservation(res, builder)
+    }
+
+    scheduledBuildsByTarget(
+        entities: ServerContract.Types.entity_info[],
+        now: Date
+    ): Map<string, ScheduledBuild> {
+        const byId = new Map(entities.map((e) => [e.id.toString(), e]))
+        const out = new Map<string, ScheduledBuild>()
+        for (const entity of entities) {
+            if (entity.type.toString() !== 'plot') continue
+            const res = this.plotReservation(entity, now)
+            if (!res) continue
+            const builder = byId.get(res.builderId.toString())
+            out.set(entity.id.toString(), this.buildFromReservation(res, builder))
+        }
+        return out
+    }
+
     reservationsFrom(
         sourceEntityId: UInt64,
         entities: ServerContract.Types.entity_info[]

package/src/managers/context.ts

@@ -27,7 +27,8 @@ export class GameContext {
     constructor(
         public readonly client: APIClient,
         public readonly server: Contract,
-        public readonly platform: Contract
+        public readonly platform: Contract,
+        public readonly atomicAssetsAccount: string = 'atomicassets'
     ) {}
 
     get entities(): EntitiesManager {

package/src/managers/index.ts

@@ -20,5 +20,6 @@ export type {
     FinalizerEntityRef,
     FinalizerCapability,
     InboundTransfer,
+    ScheduledBuild,
     Reservation,
 } from './construction-types'

package/src/managers/plot.ts

@@ -6,7 +6,7 @@ import {calc_craft_duration} from '../capabilities/crafting'
 import {TaskType} from '../types'
 import {BaseManager} from './base'
 import type {ServerContract} from '../contracts'
-import type {BuildableTarget} from './construction-types'
+import type {BuildableTarget, ScheduledBuild} from './construction-types'
 
 export interface PlotProgressInputRow {
     itemId: number
@@ -67,7 +67,8 @@ export class PlotManager extends BaseManager {
     buildableTarget(
         plot: ServerContract.Types.entity_row,
         cargo: ServerContract.Types.cargo_row[],
-        activeTask?: ServerContract.Types.task
+        activeTask?: ServerContract.Types.task,
+        scheduledBuild?: ScheduledBuild
     ): BuildableTarget {
         const progress = this.progress(plot, cargo)
         const targetItemId = Number(plot.item_id.toString())
@@ -79,10 +80,12 @@ export class PlotManager extends BaseManager {
 
         let state: BuildableTarget['state']
         const taskType = activeTask?.type.toNumber()
-        if (taskType === TaskType.CLAIMPLOT) {
-            state = 'initializing'
-        } else if (taskType === TaskType.BUILDPLOT) {
+        if (scheduledBuild?.hasStarted) {
             state = 'finalizing'
+        } else if (scheduledBuild) {
+            state = 'scheduled'
+        } else if (taskType === TaskType.CLAIMPLOT) {
+            state = 'initializing'
         } else if (progress.isComplete) {
             state = 'ready'
         } else {
@@ -101,6 +104,7 @@ export class PlotManager extends BaseManager {
             finalizeAction: Name.from('buildplot'),
             finalizerCapability: 'crafter',
             activeTask,
+            scheduledBuild,
         }
     }