@shipload/sdk 1.0.0-next.11 → 1.0.0-next.12

package/src/managers/entities.ts

@@ -1,147 +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 {Extractor} from '../entities/extractor'
-import {Factory} from '../entities/factory'
-import {Nexus} from '../entities/nexus'
+import {Entity} from '../entities/entity'
+import type {EntityTypeName} from '../data/kind-registry'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'extractor' | 'factory' | 'container' | 'nexus'
+export type {EntityTypeName} from '../data/kind-registry'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(
-        id: UInt64Type
-    ): Promise<Ship | Warehouse | Extractor | Factory | Container | Nexus> {
+    async getEntity(id: UInt64Type): Promise<Entity> {
         const result = await this.server.readonly('getentity', {
             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 | Extractor | Factory | Container | Nexus)[]> {
+        kind?: EntityTypeName
+    ): Promise<Entity[]> {
         const ownerName = this.resolveOwner(owner)
         const result = await this.server.readonly('getentities', {
             owner: ownerName,
-            entity_type: type,
+            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,
+            entity_type: kind,
         })
         return result as ServerContract.Types.entity_summary[]
     }
 
-    async getShip(id: UInt64Type): Promise<Ship> {
-        return (await this.getEntity(id)) as Ship
-    }
-
-    async getWarehouse(id: UInt64Type): Promise<Warehouse> {
-        return (await this.getEntity(id)) as Warehouse
-    }
-
-    async getContainer(id: UInt64Type): Promise<Container> {
-        return (await this.getEntity(id)) as Container
-    }
-
-    async getExtractor(id: UInt64Type): Promise<Extractor> {
-        return (await this.getEntity(id)) as Extractor
-    }
-
-    async getFactory(id: UInt64Type): Promise<Factory> {
-        return (await this.getEntity(id)) as Factory
-    }
-
-    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 getExtractors(owner: NameType | ServerContract.Types.player_row): Promise<Extractor[]> {
-        return (await this.getEntities(owner, 'extractor')) as Extractor[]
-    }
-
-    async getFactories(owner: NameType | ServerContract.Types.player_row): Promise<Factory[]> {
-        return (await this.getEntities(owner, 'factory')) as Factory[]
-    }
-
-    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')
-    }
-
-    async getExtractorSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'extractor')
-    }
-
-    async getFactorySummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'factory')
-    }
-
-    async getNexus(id: UInt64Type): Promise<Nexus> {
-        return (await this.getEntity(id)) as Nexus
-    }
-
-    async getNexuses(owner: NameType | ServerContract.Types.player_row): Promise<Nexus[]> {
-        return (await this.getEntities(owner, 'nexus')) as Nexus[]
-    }
-
-    async getNexusSummaries(
-        owner: NameType | ServerContract.Types.player_row
-    ): Promise<ServerContract.Types.entity_summary[]> {
-        return this.getSummaries(owner, 'nexus')
-    }
-
-    private wrapEntity(
-        entity: ServerContract.Types.entity_info
-    ): Ship | Warehouse | Extractor | Factory | Container | Nexus {
-        if (entity.type.equals('ship')) return new Ship(entity)
-        if (entity.type.equals('warehouse')) return new Warehouse(entity)
-        if (entity.type.equals('extractor')) return new Extractor(entity)
-        if (entity.type.equals('factory')) return new Factory(entity)
-        if (entity.type.equals('container')) return new Container(entity)
-        if (entity.type.equals('nexus')) return new Nexus(entity)
-        throw new Error(`unknown entity type: ${entity.type}`)
-    }
-
     private resolveOwner(owner: NameType | ServerContract.Types.player_row): Name {
         if (typeof owner === 'object' && owner !== null && 'owner' in owner) {
             return owner.owner

package/src/managers/index.ts

@@ -1,7 +1,7 @@
 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'

package/src/nft/atomicdata.ts

@@ -103,6 +103,8 @@ export function deserializeAtomicData(
                 result[field.name] = readZigzagInt64()
                 break
             case 'string':
+            case 'image':
+            case 'ipfs':
                 result[field.name] = readString()
                 break
             case 'uint16[]': {

package/src/nft/description.ts

@@ -25,7 +25,7 @@ import {
     ITEM_WARP_T1,
 } from '../data/item-ids'
 import {decodeStat} from '../derivation/crafting'
-import {gathererDepthForTier} from '../entities/ship-deploy'
+import {gathererDepthForTier} from '../derivation/capabilities'
 import {getItem} from '../data/catalog'
 
 function idiv(a: number, b: number): number {

package/src/resolution/resolve-item.ts

@@ -26,8 +26,9 @@ import {
     computeLoaderCapabilities,
     computeShipHullCapabilities,
     computeWarehouseHullCapabilities,
-} from '../entities/ship-deploy'
-import {computeContainerCapabilities, computeContainerT2Capabilities} from '../entities/container'
+    computeContainerCapabilities,
+    computeContainerT2Capabilities,
+} from '../derivation/capabilities'
 import {
     categoryColors,
     categoryIcons,

package/src/subscriptions/manager.ts

@@ -13,13 +13,10 @@ import type {
     WireEntity,
 } from './types'
 import {mapEntity, parseWireEntity} from './mappers'
-import type {Ship} from '../entities/ship'
-import type {Warehouse} from '../entities/warehouse'
-import type {Container} from '../entities/container'
-import type {Nexus} from '../entities/nexus'
+import type {Entity} from '../entities/entity'
 
 export type SubscriptionEntityType = 'ship' | 'warehouse' | 'container' | 'nexus'
-export type EntityInstance = Ship | Warehouse | Container | Nexus
+export type EntityInstance = Entity
 
 export interface SubscriptionsOptions {
     url: string

package/src/subscriptions/mappers.ts

@@ -1,18 +1,9 @@
 import {ServerContract} from '../contracts'
-import {Ship} from '../entities/ship'
-import {Warehouse} from '../entities/warehouse'
-import {Container} from '../entities/container'
-import {Nexus} from '../entities/nexus'
+import {Entity} from '../entities/entity'
 import type {WireEntity} from './types'
 
-export function mapEntity(
-    ei: ServerContract.Types.entity_info
-): Ship | Warehouse | Container | Nexus {
-    if (ei.type.equals('ship')) return new Ship(ei)
-    if (ei.type.equals('warehouse')) return new Warehouse(ei)
-    if (ei.type.equals('container')) return new Container(ei)
-    if (ei.type.equals('nexus')) return new Nexus(ei)
-    throw new Error(`mapEntity: unknown entity type ${ei.type.toString()}`)
+export function mapEntity(ei: ServerContract.Types.entity_info): Entity {
+    return new Entity(ei)
 }
 
 export function parseWireEntity(raw: WireEntity): ServerContract.Types.entity_info {

package/src/testing/catalog-hash.ts

@@ -0,0 +1,19 @@
+import {createHash} from 'node:crypto'
+import {readFileSync} from 'node:fs'
+
+export const CATALOG_FILES_REL = [
+    'items.json',
+    'recipes.json',
+    'entities.json',
+    'kind-registry.json',
+    'item-ids.ts',
+] as const
+
+export function computeCatalogHash(filePaths: ReadonlyArray<string>): string {
+    const hash = createHash('sha256')
+    for (const p of filePaths) {
+        hash.update(readFileSync(p))
+        hash.update('\0')
+    }
+    return hash.digest('hex')
+}

package/src/testing/index.ts

@@ -0,0 +1,2 @@
+export * from './catalog-hash'
+export * from './projection-parity'

package/src/testing/projection-parity.ts

@@ -0,0 +1,143 @@
+import type {UInt16, UInt32} from '@wharfkit/antelope'
+import type {ServerContract} from '../contracts'
+import type {ProjectedEntity} from '../scheduling/projection'
+import {type CargoStack, cargoItemToStack, mergeStacks} from '../capabilities/storage'
+
+export interface ContractProjectedState {
+    owner: {toString(): string}
+    coordinates: ServerContract.Types.coordinates
+    energy?: UInt16
+    cargomass: UInt32
+    cargo: ServerContract.Types.cargo_view[]
+    hullmass?: UInt32
+    capacity?: UInt32
+    engines?: ServerContract.Types.movement_stats
+    loaders?: ServerContract.Types.loader_stats
+    generator?: ServerContract.Types.energy_stats
+    hauler?: ServerContract.Types.hauler_stats
+}
+
+export interface ProjectionComparisonOptions {
+    step?: number
+}
+
+export function assertProjectionEquals(
+    contract: ContractProjectedState,
+    sdk: ProjectedEntity,
+    options: ProjectionComparisonOptions = {}
+): void {
+    const mismatches: string[] = []
+
+    const record = (name: string, c: unknown, s: unknown) => {
+        if (c !== s) mismatches.push(`  ${name}: contract=${fmt(c)} sdk=${fmt(s)}`)
+    }
+
+    const recordStatBlock = (name: string, c: unknown, s: unknown) => {
+        const cPresent = c !== undefined && c !== null
+        const sPresent = s !== undefined && s !== null
+        if (cPresent !== sPresent) {
+            mismatches.push(
+                `  ${name}: contract=${cPresent ? 'present' : 'absent'} sdk=${sPresent ? 'present' : 'absent'}`
+            )
+            return
+        }
+        if (!cPresent) return
+        const cn = JSON.stringify(normaliseStatBlock(c))
+        const sn = JSON.stringify(normaliseStatBlock(s))
+        if (cn !== sn) mismatches.push(`  ${name}: contract=${cn} sdk=${sn}`)
+    }
+
+    record('coordinates.x', toNum(contract.coordinates.x), Number(sdk.location.x))
+    record('coordinates.y', toNum(contract.coordinates.y), Number(sdk.location.y))
+    record('energy', toNum(contract.energy), Number(sdk.energy))
+    record('cargomass', toNum(contract.cargomass), Number(sdk.cargoMass))
+    record('hullmass', toNum(contract.hullmass), Number(sdk.shipMass))
+    record('capacity', toNum(contract.capacity), sdk.capacity ? Number(sdk.capacity) : undefined)
+
+    recordStatBlock('engines', contract.engines, sdk.engines)
+    recordStatBlock('loaders', contract.loaders, sdk.loaders)
+    recordStatBlock('generator', contract.generator, sdk.generator)
+    recordStatBlock('hauler', contract.hauler, sdk.hauler)
+
+    if (contract.cargo.length > 0 || sdk.cargo.length > 0) {
+        const contractCargo = normaliseCargo(mergeContractCargo(contract.cargo))
+        const sdkCargo = normaliseCargo(sdk.cargo)
+        if (contractCargo.length !== sdkCargo.length) {
+            mismatches.push(
+                `  cargo.length: contract=${contractCargo.length} sdk=${sdkCargo.length}`
+            )
+        } else {
+            for (let i = 0; i < contractCargo.length; i++) {
+                const c = contractCargo[i]
+                const s = sdkCargo[i]
+                if (c.itemId !== s.itemId || c.stats !== s.stats || c.quantity !== s.quantity) {
+                    mismatches.push(
+                        `  cargo[${i}]: contract={item:${c.itemId},stats:${c.stats},qty:${c.quantity}} sdk={item:${s.itemId},stats:${s.stats},qty:${s.quantity}}`
+                    )
+                }
+            }
+        }
+    }
+
+    if (mismatches.length > 0) {
+        const header =
+            options.step !== undefined
+                ? `projection divergence at step ${options.step}:`
+                : 'projection divergence:'
+        throw new Error([header, ...mismatches].join('\n'))
+    }
+}
+
+interface NormalisedStack {
+    itemId: number
+    stats: string
+    quantity: string
+}
+
+function mergeContractCargo(cargo: ServerContract.Types.cargo_view[]): CargoStack[] {
+    return cargo.reduce<CargoStack[]>(
+        (acc, row) =>
+            mergeStacks(acc, cargoItemToStack(row as unknown as ServerContract.Types.cargo_item)),
+        []
+    )
+}
+
+function normaliseCargo(cargo: CargoStack[]): NormalisedStack[] {
+    return cargo
+        .map((s) => ({
+            itemId: Number(s.item_id),
+            stats: BigInt(s.stats.toString()).toString(),
+            quantity: BigInt(s.quantity.toString()).toString(),
+        }))
+        .sort(stackSort)
+}
+
+function stackSort(a: NormalisedStack, b: NormalisedStack): number {
+    if (a.itemId !== b.itemId) return a.itemId - b.itemId
+    return a.stats < b.stats ? -1 : a.stats > b.stats ? 1 : 0
+}
+
+function toNum(v: unknown): number | undefined {
+    if (v === undefined || v === null) return undefined
+    if (typeof v === 'number') return v
+    if (typeof v === 'bigint') return Number(v)
+    if (typeof (v as {toNumber?: unknown}).toNumber === 'function') {
+        return (v as {toNumber(): number}).toNumber()
+    }
+    return Number(v as number)
+}
+
+function fmt(v: unknown): string {
+    if (v === undefined) return 'undefined'
+    if (v === null) return 'null'
+    return String(v)
+}
+
+function normaliseStatBlock(block: unknown): Record<string, number> {
+    const out: Record<string, number> = {}
+    const obj = block as Record<string, unknown>
+    for (const k of Object.keys(obj).sort()) {
+        out[k] = toNum(obj[k]) ?? 0
+    }
+    return out
+}

package/src/types/index.ts

@@ -1,3 +1,2 @@
 export * from './capabilities'
 export * from './entity'
-export * from './entity-traits'

package/src/types.ts

@@ -1,6 +1,5 @@
 import {
     type Int64Type,
-    Name,
     type UInt16,
     type UInt16Type,
     type UInt32,
@@ -72,14 +71,6 @@ export enum TaskCancelable {
     ALWAYS = 2,
 }
 
-export const EntityType = {
-    SHIP: Name.from('ship'),
-    WAREHOUSE: Name.from('warehouse'),
-    CONTAINER: Name.from('container'),
-} as const
-
-export type EntityTypeName = (typeof EntityType)[keyof typeof EntityType]
-
 export type CoordinatesType =
     | Coordinates
     | ServerContract.Types.coordinates

package/src/entities/container.ts

@@ -1,123 +0,0 @@
-import {UInt64, type UInt64Type} from '@wharfkit/antelope'
-import {ServerContract} from '../contracts'
-import type {CoordinatesType} from '../types'
-import {type FloatPosition, getInterpolatedPosition} from '../travel/travel'
-import {Location} from './location'
-import {ScheduleAccessor} from '../scheduling/accessor'
-import * as schedule from '../scheduling/schedule'
-
-export interface ContainerStateInput {
-    id: UInt64Type
-    owner: string
-    name: string
-    coordinates: CoordinatesType | {x: number; y: number; z?: number}
-    hullmass: number
-    capacity: number
-    cargomass?: number
-    cargo?: ServerContract.Types.cargo_item[]
-    schedule?: ServerContract.Types.schedule
-}
-
-export class Container extends ServerContract.Types.entity_info {
-    private _sched?: ScheduleAccessor
-
-    get name(): string {
-        return this.entity_name
-    }
-
-    get entityClass(): 'orbital' {
-        return 'orbital'
-    }
-
-    get canUndeploy(): boolean {
-        return true
-    }
-
-    get sched(): ScheduleAccessor {
-        this._sched ??= new ScheduleAccessor(this)
-        return this._sched
-    }
-
-    get isIdle(): boolean {
-        return this.is_idle
-    }
-
-    interpolatedPositionAt(now: Date): FloatPosition {
-        const taskIndex = this.sched.currentTaskIndex(now)
-        const progress = this.sched.currentTaskProgressFloat(now)
-        return getInterpolatedPosition(this, taskIndex, progress)
-    }
-
-    isLoading(now: Date): boolean {
-        return schedule.isLoading(this, now)
-    }
-
-    isUnloading(now: Date): boolean {
-        return schedule.isUnloading(this, now)
-    }
-
-    get location(): Location {
-        return Location.from(this.coordinates)
-    }
-
-    get totalMass(): UInt64 {
-        return UInt64.from(this.hullmass ?? 0).adding(this.cargomass)
-    }
-
-    get maxCapacity(): UInt64 {
-        return UInt64.from(this.capacity)
-    }
-
-    get availableCapacity(): UInt64 {
-        const cargo = UInt64.from(this.cargomass)
-        return cargo.gte(this.maxCapacity) ? UInt64.from(0) : this.maxCapacity.subtracting(cargo)
-    }
-
-    hasSpace(additionalMass: UInt64): boolean {
-        return UInt64.from(this.cargomass).adding(additionalMass).lte(this.maxCapacity)
-    }
-
-    get isFull(): boolean {
-        return UInt64.from(this.cargomass).gte(this.maxCapacity)
-    }
-
-    get orbitalAltitude(): number {
-        return this.coordinates.z?.toNumber() || 0
-    }
-}
-
-export function computeContainerCapabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const density = stats.density
-    const strength = stats.strength
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 100000 - 75 * density
-
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2997
-    const capacity = Math.floor(1000000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}
-
-export function computeContainerT2Capabilities(stats: Record<string, number>): {
-    hullmass: number
-    capacity: number
-} {
-    const strength = stats.strength
-    const density = stats.density
-    const hardness = stats.hardness
-    const saturation = stats.saturation
-
-    const hullmass = 70000 - 50 * density
-
-    const statSum = strength + hardness + saturation
-    const exponent = statSum / 2500
-    const capacity = Math.floor(1500000 * 10 ** exponent)
-
-    return {hullmass, capacity}
-}