@shipload/sdk 1.0.0-next.6 → 1.0.0-next.60

package/src/managers/base.ts

@@ -15,11 +15,15 @@ export abstract class BaseManager {
         return this.context.platform
     }
 
+    protected get atomicAssetsAccount() {
+        return this.context.atomicAssetsAccount
+    }
+
     protected async getGame() {
         return this.context.getGame()
     }
 
-    protected async getState() {
-        return this.context.getState()
+    protected async getState(reload = false) {
+        return this.context.getState(reload)
     }
 }

package/src/managers/cluster.test.ts

@@ -0,0 +1,39 @@
+import {describe, expect, test} from 'bun:test'
+import {computeFreeCells} from './cluster'
+
+describe('computeFreeCells', () => {
+    test('returns footprint cells that are not occupied', () => {
+        const footprint = [
+            {gx: 2, gy: 0},
+            {gx: 0, gy: 2},
+            {gx: 1, gy: 1},
+        ]
+        const occupied = [{gx: 2, gy: 0, entity: 7}]
+        expect(computeFreeCells(footprint, occupied)).toEqual([
+            {gx: 0, gy: 2},
+            {gx: 1, gy: 1},
+        ])
+    })
+
+    test('matches occupancy on signed coordinates', () => {
+        const footprint = [
+            {gx: -2, gy: 0},
+            {gx: 0, gy: -2},
+            {gx: -1, gy: 1},
+        ]
+        const occupied = [{gx: 0, gy: -2, entity: 9}]
+        expect(computeFreeCells(footprint, occupied)).toEqual([
+            {gx: -2, gy: 0},
+            {gx: -1, gy: 1},
+        ])
+    })
+
+    test('empty footprint yields no free cells', () => {
+        expect(computeFreeCells([], [])).toEqual([])
+    })
+
+    test('fully occupied footprint yields no free cells', () => {
+        const footprint = [{gx: 1, gy: 1}]
+        expect(computeFreeCells(footprint, [{gx: 1, gy: 1, entity: 3}])).toEqual([])
+    })
+})

package/src/managers/cluster.ts

@@ -0,0 +1,53 @@
+import {UInt16, type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface GridCell {
+    gx: number
+    gy: number
+}
+
+export interface ClusterCell extends GridCell {
+    entity: number
+}
+
+export interface Cluster {
+    root: number
+    cells: ClusterCell[]
+}
+
+export function computeFreeCells(footprint: GridCell[], occupied: ClusterCell[]): GridCell[] {
+    const taken = new Set(occupied.map((c) => `${c.gx},${c.gy}`))
+    return footprint.filter((c) => !taken.has(`${c.gx},${c.gy}`))
+}
+
+export class ClusterManager extends BaseManager {
+    async getFootprint(itemId: UInt16Type): Promise<GridCell[]> {
+        const res = (await this.server.readonly('getfootprint', {
+            item_id: UInt16.from(itemId),
+        })) as ServerContract.Types.footprint_result
+        return res.cells.map((c) => ({gx: Number(c.gx), gy: Number(c.gy)}))
+    }
+
+    async getCluster(hubId: UInt64Type): Promise<Cluster> {
+        const res = (await this.server.readonly('getcluster', {
+            hub_id: UInt64.from(hubId),
+        })) as ServerContract.Types.cluster_row
+        return {
+            root: Number(res.root),
+            cells: res.cells.map((c) => ({
+                gx: Number(c.gx),
+                gy: Number(c.gy),
+                entity: Number(c.entity),
+            })),
+        }
+    }
+
+    async freeCells(hubId: UInt64Type, hubItemId: UInt16Type): Promise<GridCell[]> {
+        const [footprint, cluster] = await Promise.all([
+            this.getFootprint(hubItemId),
+            this.getCluster(hubId),
+        ])
+        return computeFreeCells(footprint, cluster.cells)
+    }
+}

package/src/managers/construction-types.ts

@@ -0,0 +1,80 @@
+import type {Name, UInt32, UInt64} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {Item} from '../types'
+import type {Recipe} from '../data/recipes-runtime'
+import type {PlotProgress} from './plot'
+
+export type BuildState = 'initializing' | 'accepting' | 'ready' | 'scheduled' | 'finalizing'
+
+export type FinalizerCapability = 'builder'
+
+export interface BuildableTarget {
+    entityId: UInt64
+    ownerName: Name
+    coordinates: ServerContract.Types.coordinates
+    targetItemId: number
+    targetItem: Item
+    state: BuildState
+    recipe: Recipe
+    progress: PlotProgress
+    finalizeAction: Name
+    finalizerCapability: FinalizerCapability
+    activeTask?: ServerContract.Types.task
+    scheduledBuild?: ScheduledBuild
+}
+
+export interface SourceEntityRef {
+    entityId: UInt64
+    name: string
+    hasLoaders: boolean
+    loaderCount: number
+    loaderTotalMass: number
+    relevantCargo: SourceCargoStack[]
+}
+
+export interface SourceCargoStack {
+    key: string
+    rowId: UInt64
+    itemId: number
+    item: Item
+    stats: UInt64
+    modules: ServerContract.Types.module_entry[]
+    available: number
+    plotNeeds: number
+    reserved: number
+}
+
+export interface FinalizerEntityRef {
+    entityId: UInt64
+    entityType: Name
+    name: string
+    capability: FinalizerCapability
+    builderSpeed: number
+    estimatedDuration: UInt32
+}
+
+export interface InboundTransfer {
+    sourceEntityId: UInt64
+    sourceEntityType: Name
+    sourceName: string
+    itemId: number
+    quantity: number
+    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
+    itemId: number
+    quantity: number
+}

package/src/managers/construction.ts

@@ -0,0 +1,443 @@
+import type {UInt64, UInt32} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+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 {HoldKind, TaskType} from '../types'
+import type {
+    BuildableTarget,
+    FinalizerEntityRef,
+    InboundTransfer,
+    Reservation,
+    ScheduledBuild,
+    SourceCargoStack,
+    SourceEntityRef,
+} from './construction-types'
+
+const CONSTRUCTION_KINDS = new Set<string>(['plot'])
+
+export class ConstructionManager extends BaseManager {
+    private readonly plot = new PlotManager(this.context)
+
+    getTarget(
+        entity: ServerContract.Types.entity_row,
+        cargo: ServerContract.Types.cargo_row[],
+        activeTask?: ServerContract.Types.task,
+        scheduledBuild?: ScheduledBuild
+    ): BuildableTarget | null {
+        const kind = entity.kind.toString()
+        if (kind === 'plot') {
+            return this.plot.buildableTarget(entity, cargo, activeTask, scheduledBuild)
+        }
+        return null
+    }
+
+    eligibleSources(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_info[],
+        cargo: ServerContract.Types.cargo_row[]
+    ): SourceEntityRef[] {
+        return partitionSources(target, entities, cargo).eligible
+    }
+
+    unreachableSources(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_info[],
+        cargo: ServerContract.Types.cargo_row[]
+    ): SourceEntityRef[] {
+        return partitionSources(target, entities, cargo).unreachable
+    }
+
+    partitionSources(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_info[],
+        cargo: ServerContract.Types.cargo_row[]
+    ): {eligible: SourceEntityRef[]; unreachable: SourceEntityRef[]} {
+        return partitionSources(target, entities, cargo)
+    }
+
+    eligibleFinalizers(
+        target: BuildableTarget,
+        entities: ServerContract.Types.entity_info[]
+    ): FinalizerEntityRef[] {
+        const out: FinalizerEntityRef[] = []
+        for (const entity of entities) {
+            if (!entity.owner.equals(target.ownerName)) continue
+            if (entity.id.equals(target.entityId)) continue
+            if (!coordsEqual(entity.coordinates, target.coordinates)) continue
+            const builderLanes = entity.builder_lanes ?? []
+            if (builderLanes.length === 0) continue
+            const speed = builderLanes.reduce((s, l) => s + Number(l.speed), 0)
+            out.push({
+                entityId: entity.id,
+                entityType: entity.type,
+                name: entity.entity_name,
+                capability: 'builder',
+                builderSpeed: speed,
+                estimatedDuration: this.estimateFinalizeDuration(target, speed),
+            })
+        }
+        return out.sort((a, b) => a.estimatedDuration.value - b.estimatedDuration.value)
+    }
+
+    inboundTransfersTo(
+        plotId: UInt64,
+        entities: ServerContract.Types.entity_info[],
+        now: Date
+    ): InboundTransfer[] {
+        return this.inboundTransfersByTarget(entities, now).get(plotId.toString()) ?? []
+    }
+
+    inboundTransfersByTarget(
+        entities: ServerContract.Types.entity_info[],
+        now: Date
+    ): Map<string, InboundTransfer[]> {
+        const buckets = new Map<string, Map<string, InboundTransfer>>()
+        const entitiesById = new Map(entities.map((entity) => [entity.id.toString(), entity]))
+        const nowMs = now.getTime()
+        for (const entity of entities) {
+            for (const lane of getLanes(entity)) {
+                const startedMs = lane.schedule.started.toDate().getTime()
+                let cumulativeSec = 0
+                for (const task of lane.schedule.tasks) {
+                    cumulativeSec += task.duration.toNumber()
+                    if (!isDeliveryTask(task)) continue
+                    const target = deliveryTarget(task)
+                    if (!target) continue
+                    const source = deliverySource(task, entity, entitiesById)
+                    if (!source) continue
+                    const projectedEndMs = startedMs + cumulativeSec * 1000
+                    if (projectedEndMs < nowMs) continue
+                    const targetIdStr = target.entity_id.toString()
+                    const sourceIdStr = source.id.toString()
+                    const sourceName = source.entity_name || sourceIdStr
+                    const etaSeconds = Math.max(0, Math.round((projectedEndMs - nowMs) / 1000))
+                    let perTarget = buckets.get(targetIdStr)
+                    if (!perTarget) {
+                        perTarget = new Map()
+                        buckets.set(targetIdStr, perTarget)
+                    }
+                    for (const c of task.cargo) {
+                        const itemId = c.item_id.toNumber()
+                        const quantity = c.quantity.toNumber()
+                        if (quantity === 0) continue
+                        const key = `${sourceIdStr}#${itemId}`
+                        const existing = perTarget.get(key)
+                        if (existing) {
+                            existing.quantity += quantity
+                            existing.etaSeconds = Math.min(existing.etaSeconds, etaSeconds)
+                        } else {
+                            perTarget.set(key, {
+                                sourceEntityId: source.id,
+                                sourceEntityType: source.type,
+                                sourceName,
+                                itemId,
+                                quantity,
+                                etaSeconds,
+                            })
+                        }
+                    }
+                }
+            }
+        }
+        const out = new Map<string, InboundTransfer[]>()
+        for (const [targetId, perTarget] of buckets) {
+            out.set(targetId, Array.from(perTarget.values()))
+        }
+        return out
+    }
+
+    private plotReservation(
+        plot: ServerContract.Types.entity_info,
+        builder: ServerContract.Types.entity_info | undefined,
+        now: Date
+    ): {
+        builderId: UInt64
+        startsAt: number
+        completesAt: number
+        hasStarted: boolean
+    } | null {
+        const hold = plot.holds.find((h) => h.kind.toNumber() === HoldKind.BUILD)
+        if (!hold) return null
+        const builderId = hold.counterpart.entity_id
+        const completesAt = hold.until.toDate().getTime()
+        const startsAt = this.builderBuildStart(builder, plot.id) ?? completesAt
+        return {
+            builderId,
+            startsAt,
+            completesAt,
+            hasStarted: startsAt <= now.getTime(),
+        }
+    }
+
+    private builderBuildStart(
+        builder: ServerContract.Types.entity_info | undefined,
+        plotId: UInt64
+    ): number | undefined {
+        if (!builder) return undefined
+        for (const lane of getLanes(builder)) {
+            const startedMs = lane.schedule.started.toDate().getTime()
+            let startSec = 0
+            for (const task of lane.schedule.tasks) {
+                if (isBuildOfPlot(task, plotId)) return startedMs + startSec * 1000
+                startSec += task.duration.toNumber()
+            }
+        }
+        return undefined
+    }
+
+    private builderCancelability(
+        builder: ServerContract.Types.entity_info | undefined,
+        plotId: UInt64
+    ): {cancelable: boolean; blockingTaskCount: number} {
+        if (!builder) {
+            return {cancelable: false, blockingTaskCount: 0}
+        }
+        for (const lane of getLanes(builder)) {
+            const tasks = lane.schedule.tasks
+            const buildIdx = tasks.findIndex((t) => isBuildOfPlot(t, plotId))
+            if (buildIdx < 0) continue
+            const trailing = tasks.length - 1 - buildIdx
+            return {cancelable: trailing === 0, blockingTaskCount: trailing}
+        }
+        return {cancelable: false, blockingTaskCount: 0}
+    }
+
+    private buildFromReservation(
+        res: {
+            builderId: UInt64
+            startsAt: number
+            completesAt: number
+            hasStarted: boolean
+        },
+        plotId: UInt64,
+        builder: ServerContract.Types.entity_info | undefined
+    ): ScheduledBuild {
+        const {cancelable, blockingTaskCount} = this.builderCancelability(builder, plotId)
+        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 hold = plot.holds.find((h) => h.kind.toNumber() === HoldKind.BUILD)
+        if (!hold) return null
+        const builder = entities.find((e) => e.id.equals(hold.counterpart.entity_id))
+        const res = this.plotReservation(plot, builder, now)
+        if (!res) return null
+        return this.buildFromReservation(res, plot.id, 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 hold = entity.holds.find((h) => h.kind.toNumber() === HoldKind.BUILD)
+            if (!hold) continue
+            const builder = byId.get(hold.counterpart.entity_id.toString())
+            const res = this.plotReservation(entity, builder, now)
+            if (!res) continue
+            out.set(entity.id.toString(), this.buildFromReservation(res, entity.id, builder))
+        }
+        return out
+    }
+
+    reservationsFrom(
+        sourceEntityId: UInt64,
+        entities: ServerContract.Types.entity_info[]
+    ): Reservation[] {
+        const source = entities.find((e) => e.id.equals(sourceEntityId))
+        if (!source) return []
+        return reservationsOf(source)
+    }
+
+    estimateFinalizeDuration(target: BuildableTarget, builderSpeed: number): UInt32 {
+        return calc_build_duration(builderSpeed, target.progress.massRequired)
+    }
+
+    static isConstructionKind(kind: string): boolean {
+        return CONSTRUCTION_KINDS.has(kind)
+    }
+}
+
+function coordsEqual(
+    a: ServerContract.Types.coordinates,
+    b: ServerContract.Types.coordinates
+): boolean {
+    return a.x.equals(b.x) && a.y.equals(b.y)
+}
+
+function moduleKey(module: ServerContract.Types.module_entry): string {
+    const installed = module.installed
+    if (!installed) return `${module.type.toNumber()}:empty`
+
+    return `${module.type.toNumber()}:${installed.item_id.toNumber()}:${installed.stats.toString()}`
+}
+
+function sourceStackKey(cargo: ServerContract.Types.cargo_row): string {
+    return `${cargo.item_id.toNumber()}#${cargo.stats.toString()}#${(cargo.modules ?? [])
+        .map(moduleKey)
+        .join(',')}`
+}
+
+function matchRelevantCargo(
+    entity: ServerContract.Types.entity_info,
+    target: BuildableTarget,
+    cargo: ServerContract.Types.cargo_row[],
+    reservedByItem: Map<number, number>
+): SourceCargoStack[] {
+    const needsByItemId = new Map(
+        target.progress.rows.filter((row) => row.missing > 0).map((row) => [row.itemId, row])
+    )
+    const remainingReserved = new Map(reservedByItem)
+    const out: SourceCargoStack[] = []
+    for (const c of cargo) {
+        if (!c.entity_id.equals(entity.id)) continue
+        const itemId = c.item_id.toNumber()
+        const need = needsByItemId.get(itemId)
+        if (!need) continue
+        const gross = c.quantity.toNumber()
+        if (gross === 0) continue
+        const reservedRemaining = remainingReserved.get(itemId) ?? 0
+        const reserved = Math.min(gross, reservedRemaining)
+        const available = gross - reserved
+        if (reserved > 0) {
+            remainingReserved.set(itemId, reservedRemaining - reserved)
+        }
+        if (available === 0) continue
+        out.push({
+            key: sourceStackKey(c),
+            rowId: c.id,
+            itemId,
+            item: getItem(itemId),
+            stats: c.stats,
+            modules: c.modules ?? [],
+            available,
+            plotNeeds: need.missing,
+            reserved,
+        })
+    }
+    return out
+}
+
+function partitionSources(
+    target: BuildableTarget,
+    entities: ServerContract.Types.entity_info[],
+    cargo: ServerContract.Types.cargo_row[]
+): {eligible: SourceEntityRef[]; unreachable: SourceEntityRef[]} {
+    const eligible: SourceEntityRef[] = []
+    const unreachable: SourceEntityRef[] = []
+    for (const entity of entities) {
+        if (!entity.owner.equals(target.ownerName)) continue
+        if (entity.id.equals(target.entityId)) continue
+        if (!coordsEqual(entity.coordinates, target.coordinates)) continue
+        const reserved = reservedByItemFor(entity)
+        const relevant = matchRelevantCargo(entity, target, cargo, reserved)
+        if (relevant.length === 0) continue
+        const loaderLanes = entity.loader_lanes ?? []
+        const loaderCount = loaderLanes.length
+        const loaderTotalMass = loaderLanes.reduce((s, l) => s + Number(l.mass), 0)
+        const ref: SourceEntityRef = {
+            entityId: entity.id,
+            name: entity.id.toString(),
+            hasLoaders: loaderCount > 0,
+            loaderCount,
+            loaderTotalMass,
+            relevantCargo: relevant,
+        }
+        if (ref.hasLoaders) eligible.push(ref)
+        else unreachable.push(ref)
+    }
+    return {eligible, unreachable}
+}
+
+function isDeliveryTask(task: ServerContract.Types.task): boolean {
+    const type = task.type.toNumber()
+    return type === TaskType.UNLOAD || type === TaskType.SHUTTLE
+}
+
+function deliveryTarget(
+    task: ServerContract.Types.task
+): ServerContract.Types.entity_ref | undefined {
+    if (task.type.toNumber() === TaskType.SHUTTLE) {
+        return task.couplings.find((coupling) => coupling.kind.toNumber() === HoldKind.PUSH)
+            ?.counterpart
+    }
+    return task.couplings[0]?.counterpart
+}
+
+function deliverySource(
+    task: ServerContract.Types.task,
+    transporter: ServerContract.Types.entity_info,
+    entitiesById: ReadonlyMap<string, ServerContract.Types.entity_info>
+): ServerContract.Types.entity_info | undefined {
+    if (task.type.toNumber() !== TaskType.SHUTTLE) return transporter
+    const source = task.couplings.find(
+        (coupling) => coupling.kind.toNumber() === HoldKind.PULL
+    )?.counterpart
+    return source ? entitiesById.get(source.entity_id.toString()) : undefined
+}
+
+function isReservingPushTask(task: ServerContract.Types.task): boolean {
+    return task.type.toNumber() === TaskType.UNLOAD
+}
+
+function isBuildOfPlot(task: ServerContract.Types.task, plotId: UInt64): boolean {
+    return (
+        task.type.toNumber() === TaskType.BUILDPLOT &&
+        task.couplings.length > 0 &&
+        task.couplings[0].counterpart.entity_id.equals(plotId)
+    )
+}
+
+function reservationsOf(source: ServerContract.Types.entity_info): Reservation[] {
+    const out = new Map<string, Reservation>()
+    for (const task of getTasks(source)) {
+        if (!isReservingPushTask(task)) continue
+        if (task.couplings.length === 0) continue
+        const targetType = task.couplings[0].counterpart.entity_type
+        const targetId = task.couplings[0].counterpart.entity_id
+        for (const c of task.cargo) {
+            const itemId = c.item_id.toNumber()
+            const quantity = c.quantity.toNumber()
+            if (quantity === 0) continue
+            const key = `${targetId.toString()}#${itemId}`
+            const existing = out.get(key)
+            if (existing) {
+                existing.quantity += quantity
+            } else {
+                out.set(key, {
+                    targetEntityId: targetId,
+                    targetEntityType: targetType,
+                    itemId,
+                    quantity,
+                })
+            }
+        }
+    }
+    return Array.from(out.values())
+}
+
+function reservedByItemFor(source: ServerContract.Types.entity_info): Map<number, number> {
+    const out = new Map<number, number>()
+    for (const r of reservationsOf(source)) {
+        out.set(r.itemId, (out.get(r.itemId) ?? 0) + r.quantity)
+    }
+    return out
+}

package/src/managers/context.ts

@@ -6,16 +6,22 @@ import {GameState} from '../entities/gamestate'
 import {EntitiesManager} from './entities'
 import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
+import {CoordinatesManager} from './coordinates'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
+import {ClusterManager} from './cluster'
+import {NftManager} from './nft'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
     private _entities?: EntitiesManager
     private _players?: PlayersManager
     private _locations?: LocationsManager
+    private _coordinates?: CoordinatesManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
+    private _clusters?: ClusterManager
+    private _nft?: NftManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -25,7 +31,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 {
@@ -49,6 +56,13 @@ export class GameContext {
         return this._locations
     }
 
+    get coordinates(): CoordinatesManager {
+        if (!this._coordinates) {
+            this._coordinates = new CoordinatesManager(this)
+        }
+        return this._coordinates
+    }
+
     get epochs(): EpochsManager {
         if (!this._epochs) {
             this._epochs = new EpochsManager(this)
@@ -63,6 +77,20 @@ export class GameContext {
         return this._actions
     }
 
+    get clusters(): ClusterManager {
+        if (!this._clusters) {
+            this._clusters = new ClusterManager(this)
+        }
+        return this._clusters
+    }
+
+    get nft(): NftManager {
+        if (!this._nft) {
+            this._nft = new NftManager(this)
+        }
+        return this._nft
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }