@shipload/sdk 1.0.0-next.4 → 1.0.0-next.41

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/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 = 'crafter'
+
+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
+    crafterSpeed: 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,412 @@
+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_craft_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 crafterLanes = entity.crafter_lanes ?? []
+            if (crafterLanes.length === 0) continue
+            const speed = crafterLanes.reduce((s, l) => s + Number(l.speed), 0)
+            out.push({
+                entityId: entity.id,
+                entityType: entity.type,
+                name: entity.entity_name,
+                capability: 'crafter',
+                crafterSpeed: 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 nowMs = now.getTime()
+        for (const entity of entities) {
+            const entityIdStr = entity.id.toString()
+            const sourceName = entity.entity_name || entityIdStr
+            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 (!isPushTask(task)) continue
+                    if (!task.entitytarget) continue
+                    const projectedEndMs = startedMs + cumulativeSec * 1000
+                    if (projectedEndMs < nowMs) continue
+                    const targetIdStr = task.entitytarget.entity_id.toString()
+                    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 = `${entityIdStr}#${itemId}`
+                        const existing = perTarget.get(key)
+                        if (existing) {
+                            existing.quantity += quantity
+                            existing.etaSeconds = Math.min(existing.etaSeconds, etaSeconds)
+                        } else {
+                            perTarget.set(key, {
+                                sourceEntityId: entity.id,
+                                sourceEntityType: entity.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, crafterSpeed: number): UInt32 {
+        return calc_craft_duration(crafterSpeed, 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 isPushTask(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.entitytarget !== undefined &&
+        task.entitytarget.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 (!isPushTask(task)) continue
+        if (!task.entitytarget) continue
+        const targetType = task.entitytarget.entity_type
+        const targetId = task.entitytarget.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,20 @@ 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 {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 _nft?: NftManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -25,7 +29,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 +54,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 +75,13 @@ export class GameContext {
         return this._actions
     }
 
+    get nft(): NftManager {
+        if (!this._nft) {
+            this._nft = new NftManager(this)
+        }
+        return this._nft
+    }
+
     setSubscriptionsUrl(url: string) {
         this._subscriptionsUrl = url
     }

package/src/managers/coordinates.ts

@@ -0,0 +1,14 @@
+import {BaseManager} from './base'
+import {type CoordinateAddress, decodeAddress, encodeAddressMemo} from '../coordinates'
+
+export class CoordinatesManager extends BaseManager {
+    async encode(x: number, y: number): Promise<CoordinateAddress> {
+        const game = await this.getGame()
+        return encodeAddressMemo(game.config.seed, x, y)
+    }
+
+    async decode(addr: CoordinateAddress): Promise<{x: number; y: number}> {
+        const game = await this.getGame()
+        return decodeAddress(game.config.seed, addr)
+    }
+}

package/src/managers/entities.ts

@@ -1,99 +1,51 @@
 import {Name, type NameType, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {Ship} from '../entities/ship'
-import {Warehouse} from '../entities/warehouse'
-import {Container} from '../entities/container'
+import {Entity} from '../entities/entity'
+import type {EntityTypeName} from '../data/kind-registry'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'container' | 'location'
+export type {EntityTypeName} from '../data/kind-registry'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(type: EntityType, id: UInt64Type): Promise<Ship | Warehouse | Container> {
+    async getEntity(id: UInt64Type): Promise<Entity> {
         const result = await this.server.readonly('getentity', {
-            entity_type: Name.from(type),
             entity_id: id,
         })
-        const entityInfo = result as ServerContract.Types.entity_info
-        return this.wrapEntity(entityInfo)
+        return new Entity(result as ServerContract.Types.entity_info)
+    }
+
+    async getProjection(id: UInt64Type, taskCount?: number): Promise<unknown> {
+        return this.server.readonly('getprojstate', {
+            entity_id: id,
+            task_count: taskCount,
+        })
     }
 
     async getEntities(
         owner: NameType | ServerContract.Types.player_row,
-        type?: EntityType
-    ): Promise<(Ship | Warehouse | Container)[]> {
+        kind?: EntityTypeName
+    ): Promise<Entity[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: kind,
         })
         const entities = result as ServerContract.Types.entity_info[]
-        return entities.map((entity) => this.wrapEntity(entity))
+        return entities.map((e) => new Entity(e))
     }
 
     async getSummaries(
         owner: NameType | ServerContract.Types.player_row,
-        type?: EntityType
+        kind?: EntityTypeName
     ): Promise<ServerContract.Types.entity_summary[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getsummaries', {
             owner: ownerName,
-            entity_type: type ? Name.from(type) : null,
+            entity_type: kind,
         })
         return result as ServerContract.Types.entity_summary[]
     }
 
-    async getShip(id: UInt64Type): Promise<Ship> {
-        return (await this.getEntity('ship', id)) as Ship
-    }
-
-    async getWarehouse(id: UInt64Type): Promise<Warehouse> {
-        return (await this.getEntity('warehouse', id)) as Warehouse
-    }
-
-    async getContainer(id: UInt64Type): Promise<Container> {
-        return (await this.getEntity('container', id)) as Container
-    }
-
-    async getShips(owner: NameType | ServerContract.Types.player_row): Promise<Ship[]> {
-        return (await this.getEntities(owner, 'ship')) as Ship[]
-    }
-
-    async getWarehouses(owner: NameType | ServerContract.Types.player_row): Promise<Warehouse[]> {
-        return (await this.getEntities(owner, 'warehouse')) as Warehouse[]
-    }
-
-    async getContainers(owner: NameType | ServerContract.Types.player_row): Promise<Container[]> {
-        return (await this.getEntities(owner, 'container')) as Container[]
-    }
-
-    async getShipSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'ship')
-    }
-
-    async getWarehouseSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'warehouse')
-    }
-
-    async getContainerSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        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)
-        }
-    }
-
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner