@shipload/sdk 1.0.0-next.3 → 1.0.0-next.31

package/src/managers/construction.ts

@@ -0,0 +1,396 @@
+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 {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 speed = entity.crafter?.speed.toNumber()
+            if (speed === undefined) continue
+            out.push({
+                entityId: entity.id,
+                name: entity.id.toString(),
+                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 (!isTransferTask(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,
+        now: Date
+    ): {
+        builderId: UInt64
+        group?: UInt64
+        startsAt: number
+        completesAt: number
+        hasStarted: boolean
+    } | null {
+        for (const lane of getLanes(plot)) {
+            const startedMs = lane.schedule.started.toDate().getTime()
+            let startSec = 0
+            for (const task of lane.schedule.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 || group === undefined) {
+            return {cancelable: false, blockingTaskCount: 0}
+        }
+        for (const lane of getLanes(builder)) {
+            const tasks = lane.schedule.tasks
+            const buildIdx = tasks.findIndex(
+                (t) =>
+                    t.type.toNumber() === TaskType.BUILDPLOT &&
+                    t.entitygroup !== undefined &&
+                    t.entitygroup.equals(group)
+            )
+            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
+            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[]
+    ): 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 loaderCount = entity.loaders?.quantity.toNumber() ?? 0
+        const loaderTotalMass = entity.loaders?.mass.toNumber() ?? 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 isTransferTask(task: ServerContract.Types.task): boolean {
+    const type = task.type.toNumber()
+    return type === TaskType.LOAD || type === TaskType.UNLOAD
+}
+
+function reservationsOf(source: ServerContract.Types.entity_info): Reservation[] {
+    const out = new Map<string, Reservation>()
+    for (const task of getTasks(source)) {
+        if (!isTransferTask(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

@@ -8,6 +8,7 @@ import {PlayersManager} from './players'
 import {LocationsManager} from './locations'
 import {EpochsManager} from './epochs'
 import {ActionsManager} from './actions'
+import {NftManager} from './nft'
 import {SubscriptionsManager} from '../subscriptions/manager'
 
 export class GameContext {
@@ -16,6 +17,7 @@ export class GameContext {
     private _locations?: LocationsManager
     private _epochs?: EpochsManager
     private _actions?: ActionsManager
+    private _nft?: NftManager
     private _subscriptions?: SubscriptionsManager
     private _subscriptionsUrl?: string
 
@@ -25,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 {
@@ -63,6 +66,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/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

package/src/managers/epochs.ts

@@ -1,6 +1,7 @@
 import {UInt64, type UInt64Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
 import {type EpochInfo, getCurrentEpoch, getEpochInfo} from '../scheduling/epoch'
+import type {ServerContract} from '../contracts'
 
 export class EpochsManager extends BaseManager {
     async getCurrentHeight(): Promise<UInt64> {
@@ -8,6 +9,11 @@ export class EpochsManager extends BaseManager {
         return getCurrentEpoch(game)
     }
 
+    async getFinalizedEpoch(reload = false): Promise<UInt64> {
+        const state = await this.getState(reload)
+        return state.currentEpoch
+    }
+
     async getCurrent(): Promise<EpochInfo> {
         const game = await this.getGame()
         const epoch = await this.getCurrentHeight()
@@ -44,4 +50,38 @@ export class EpochsManager extends BaseManager {
         const remaining = await this.getTimeRemaining()
         return durationMs <= remaining
     }
+
+    async getEpochRow(epoch: UInt64Type): Promise<ServerContract.Types.epoch_row | undefined> {
+        const target = UInt64.from(epoch)
+        return this.server.table('epoch').get(target)
+    }
+
+    async getActiveEpochInfo(): Promise<ServerContract.Types.epoch_row | undefined> {
+        const rows = await this.server.table('epoch').all()
+        if (rows.length === 0) {
+            return undefined
+        }
+        return rows[rows.length - 1]
+    }
+
+    async getOracles(): Promise<ServerContract.Types.oracle_row[]> {
+        return this.server.table('oracles').all()
+    }
+
+    async getThreshold(): Promise<number> {
+        const cfg = await this.server.table('oraclecfg').get()
+        return cfg ? Number(cfg.threshold) : 0
+    }
+
+    async getCommitsFor(epoch: UInt64Type): Promise<ServerContract.Types.commit_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('commit').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
+
+    async getRevealsFor(epoch: UInt64Type): Promise<ServerContract.Types.reveal_row[]> {
+        const target = UInt64.from(epoch)
+        const rows = await this.server.table('reveal').all()
+        return rows.filter((r) => r.epoch.equals(target))
+    }
 }

package/src/managers/index.ts

@@ -1,9 +1,25 @@
 export {GameContext} from './context'
 export {BaseManager} from './base'
 export {EntitiesManager} from './entities'
-export type {EntityType} from './entities'
+export type {EntityTypeName} from './entities'
 export {PlayersManager} from './players'
 export {LocationsManager} from './locations'
 export type {LocationStratum} from './locations'
 export {EpochsManager} from './epochs'
 export {ActionsManager} from './actions'
+export {NftManager} from './nft'
+export type {NftConfigForItem} from './nft'
+export {PlotManager} from './plot'
+export type {PlotProgress, PlotProgressInputRow} from './plot'
+export {ConstructionManager} from './construction'
+export type {
+    BuildableTarget,
+    BuildState,
+    SourceEntityRef,
+    SourceCargoStack,
+    FinalizerEntityRef,
+    FinalizerCapability,
+    InboundTransfer,
+    ScheduledBuild,
+    Reservation,
+} from './construction-types'