@shipload/sdk 1.0.0-next.2 → 1.0.0-next.21

package/src/managers/construction.ts

@@ -0,0 +1,292 @@
+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 {TaskType} from '../types'
+import type {
+    BuildableTarget,
+    FinalizerEntityRef,
+    InboundTransfer,
+    Reservation,
+    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
+    ): BuildableTarget | null {
+        const kind = entity.kind.toString()
+        if (kind === 'plot') {
+            return this.plot.buildableTarget(entity, cargo, activeTask)
+        }
+        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 schedule = entity.schedule
+            if (!schedule) continue
+            const entityIdStr = entity.id.toString()
+            const sourceName = entity.entity_name || entityIdStr
+            const startedMs = schedule.started.toDate().getTime()
+            let cumulativeSec = 0
+            for (const task of schedule.tasks) {
+                cumulativeSec += task.duration.toNumber()
+                if (!isTransferTask(task)) continue
+                if (!task.entitytarget) continue
+                const targetIdStr = task.entitytarget.entity_id.toString()
+                const etaSeconds = Math.max(
+                    0,
+                    Math.round((startedMs + cumulativeSec * 1000 - 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
+    }
+
+    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[] {
+    if (!source.schedule) return []
+    const out = new Map<string, Reservation>()
+    for (const task of source.schedule.tasks) {
+        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
 
@@ -63,6 +65,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,24 @@
 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,
+    Reservation,
+} from './construction-types'

package/src/managers/locations.ts

@@ -1,6 +1,6 @@
-import {type UInt16Type, UInt64, type UInt64Type} from '@wharfkit/antelope'
+import type {UInt16Type} from '@wharfkit/antelope'
 import {BaseManager} from './base'
-import {type CoordinatesType, coordsToLocationId, type Distance} from '../types'
+import type {CoordinatesType, Distance} from '../types'
 import {hasSystem} from '../utils/system'
 import {findNearbyPlanets} from '../travel/travel'
 import type {ServerContract} from '../contracts'
@@ -47,22 +47,4 @@ export class LocationsManager extends BaseManager {
             reserve: overrideMap.get(s.index) ?? s.reserve,
         }))
     }
-
-    async getLocationEntity(
-        id: UInt64Type
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const row = await this.server.table('location').get(UInt64.from(id))
-        return row ?? undefined
-    }
-
-    async getLocationEntityAt(
-        coords: CoordinatesType
-    ): Promise<ServerContract.Types.location_row | undefined> {
-        const id = coordsToLocationId(coords)
-        return this.getLocationEntity(id)
-    }
-
-    async getAllLocationEntities(): Promise<ServerContract.Types.location_row[]> {
-        return this.server.table('location').all()
-    }
 }

package/src/managers/nft.ts

@@ -0,0 +1,28 @@
+import {UInt64, type UInt64Type} from '@wharfkit/antelope'
+import {BaseManager} from './base'
+import type {ServerContract} from '../contracts'
+
+export interface NftConfigForItem {
+    templateId: number
+    schemaName: string
+}
+
+export class NftManager extends BaseManager {
+    private cache = new Map<string, NftConfigForItem | null>()
+
+    async getNftConfigForItem(itemId: UInt64Type): Promise<NftConfigForItem | undefined> {
+        const id = UInt64.from(itemId)
+        const key = id.toString()
+        if (this.cache.has(key)) {
+            return this.cache.get(key) ?? undefined
+        }
+        const row = (await this.server.table('nftconfig').get(id)) as
+            | ServerContract.Types.nftconfig_row
+            | undefined
+        const result: NftConfigForItem | null = row
+            ? {templateId: Number(row.template_id), schemaName: String(row.schema_name)}
+            : null
+        this.cache.set(key, result)
+        return result ?? undefined
+    }
+}