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

package/src/entities/makers.ts

@@ -1,51 +1,54 @@
 import {Name, UInt16, UInt32, UInt64, UInt8} from '@wharfkit/antelope'
+import type {NameType, UInt64Type} from '@wharfkit/antelope'
 import {ServerContract} from '../contracts'
-import {type PackedModuleInput, Ship, type ShipStateInput} from './ship'
-import {computeWarehouseCapabilities, Warehouse, type WarehouseStateInput} from './warehouse'
-import {Container, type ContainerStateInput} from './container'
-import {Nexus, type NexusStateInput} from './nexus'
-import {Extractor, computeExtractorCapabilities, type ExtractorStateInput} from './extractor'
-import {Factory, computeFactoryCapabilities, type FactoryStateInput} from './factory'
-import {
-    ITEM_EXTRACTOR_T1_PACKED,
-    ITEM_FACTORY_T1_PACKED,
-    ITEM_SHIP_T1_PACKED,
-    ITEM_WAREHOUSE_T1_PACKED,
-} from '../data/item-ids'
-import {getEntityLayout, type EntitySlot} from '../data/recipes-runtime'
+import {Entity} from './entity'
+import {getKindMeta, getTemplateMeta} from '../data/kind-registry'
+import type {EntityTypeName} from '../data/kind-registry'
+import {getEntityLayout} from '../data/recipes-runtime'
+import type {EntitySlot} from '../data/recipes-runtime'
 import {itemMetadata} from '../data/metadata'
 import {getItem} from '../data/catalog'
-import {
-    getModuleCapabilityType,
-    MODULE_STORAGE,
-    moduleAccepts,
-    moduleSlotTypeToCode,
-} from '../capabilities/modules'
-import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
+import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
+import {computeEntityCapabilities} from '../derivation/capabilities'
 import type {InstalledModule} from './slot-multiplier'
-import {decodeCraftedItemStats} from '../derivation/crafting'
+
+export interface PackedModuleInput {
+    itemId: number
+    stats: bigint
+}
+
+export interface EntityStateInput {
+    id: UInt64Type
+    owner: NameType
+    name: string
+    coordinates: {x: number; y: number; z?: number}
+    hullmass?: number
+    capacity?: number
+    cargomass?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    cargo?: ServerContract.Types.cargo_item[]
+}
 
 function assignModulesToSlots(
-    packedEntityItemId: number,
+    slots: EntitySlot[],
     modules: PackedModuleInput[],
     entityLabel: string
 ): ServerContract.Types.module_entry[] {
-    const layout = getEntityLayout(packedEntityItemId)
-    const slots = layout?.slots ?? []
     const result: Array<{type: number; installed?: ServerContract.Types.packed_module}> = slots.map(
         (s) => ({type: moduleSlotTypeToCode(s.type), installed: undefined})
     )
 
     for (const mod of modules) {
-        const itemId = Number(UInt16.from(mod.itemId).value.toString())
-        const modType = getModuleCapabilityType(itemId)
+        const modType = getModuleCapabilityType(mod.itemId)
         const slotIdx = result.findIndex((r) => !r.installed && moduleAccepts(r.type, modType))
         if (slotIdx === -1) {
             let modName: string
             try {
-                modName = getItem(itemId).name
+                modName = getItem(mod.itemId).name
             } catch {
-                modName = itemMetadata[itemId]?.name ?? `item ${itemId}`
+                modName = itemMetadata[mod.itemId]?.name ?? `item ${mod.itemId}`
             }
             throw new Error(
                 `No compatible slot for module ${modName} (type ${modType}) on ${entityLabel}`
@@ -71,236 +74,80 @@ function toInstalledModules(entries: ServerContract.Types.module_entry[]): Insta
         if (!entry.installed) return
         installed.push({
             slotIndex,
-            itemId: Number(UInt16.from(entry.installed.item_id).value.toString()),
-            stats: BigInt(UInt64.from(entry.installed.stats).toString()),
+            itemId: Number(entry.installed.item_id.value),
+            stats: BigInt(entry.installed.stats.toString()),
         })
     })
     return installed
 }
 
-function computeStorageBonus(modules: InstalledModule[], baseCapacity: number): number {
-    let totalBonus = 0
-    for (const m of modules) {
-        if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
-        const stats = decodeCraftedItemStats(m.itemId, m.stats)
-        const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
-        totalBonus += capacityBonus
-    }
-    return totalBonus
-}
-
-function deriveShipFromModules(
-    moduleEntries: ServerContract.Types.module_entry[],
-    layout: EntitySlot[],
-    baseCapacity: number
-): {
-    capabilities: ReturnType<typeof computeShipCapabilities>
-    finalCapacity: number
-} {
-    const installed = toInstalledModules(moduleEntries)
-    const capabilities = computeShipCapabilities(installed, layout)
-    const totalBonus = computeStorageBonus(installed, baseCapacity)
-    return {capabilities, finalCapacity: baseCapacity + totalBonus}
+const ZERO_HULL_STATS: Record<string, number> = {
+    density: 0,
+    strength: 0,
+    hardness: 0,
+    saturation: 0,
 }
 
-export function makeShip(state: ShipStateInput): Ship {
-    const info: Record<string, unknown> = {
-        type: Name.from('ship'),
-        id: UInt64.from(state.id),
-        owner: Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        cargomass: UInt32.from(0),
-        cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
-    }
-    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.schedule) info.schedule = state.schedule
-
-    let moduleEntries: ServerContract.Types.module_entry[] = []
-    const shipLayout = getEntityLayout(ITEM_SHIP_T1_PACKED)?.slots ?? []
-    if (state.modules && state.modules.length > 0) {
-        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
-        const {capabilities, finalCapacity} = deriveShipFromModules(
-            moduleEntries,
-            shipLayout,
-            state.capacity ?? 0
-        )
-        if (capabilities.engines) info.engines = capabilities.engines
-        if (capabilities.generator) info.generator = capabilities.generator
-        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
-        if (capabilities.hauler) info.hauler = capabilities.hauler
-        if (capabilities.loaders) info.loaders = capabilities.loaders
-        if (capabilities.crafter) info.crafter = capabilities.crafter
-        if (state.capacity !== undefined) info.capacity = UInt32.from(finalCapacity)
-    } else {
-        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, [], 'Ship T1')
-        if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+export function makeEntity(packedItemId: number, state: EntityStateInput): Entity {
+    const template = getTemplateMeta(packedItemId)
+    if (!template) {
+        throw new Error(`Unknown packed entity item ID: ${packedItemId}`)
     }
 
-    info.modules = moduleEntries
-
-    const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Ship(entityInfo)
-}
+    const kind = template.kind.toString() as EntityTypeName
+    const layout = getEntityLayout(packedItemId)?.slots ?? []
+    const mods = state.modules ?? []
 
-export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     const info: Record<string, unknown> = {
-        type: Name.from('warehouse'),
+        type: template.kind,
         id: UInt64.from(state.id),
         owner: Name.from(state.owner),
         entity_name: state.name,
         coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        capacity: UInt32.from(state.capacity),
-        cargomass: UInt32.from(0),
+        cargomass: UInt32.from(state.cargomass ?? 0),
         cargo: state.cargo || [],
         is_idle: !state.schedule,
         current_task_elapsed: UInt32.from(0),
         current_task_remaining: UInt32.from(0),
         pending_tasks: [],
     }
-    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.schedule) info.schedule = state.schedule
-
-    let moduleEntries: ServerContract.Types.module_entry[] = []
-    const warehouseLayout = getEntityLayout(ITEM_WAREHOUSE_T1_PACKED)?.slots ?? []
-    if (state.modules && state.modules.length > 0) {
-        moduleEntries = assignModulesToSlots(
-            ITEM_WAREHOUSE_T1_PACKED,
-            state.modules,
-            'Warehouse T1'
-        )
-        const installed = toInstalledModules(moduleEntries)
-        const capabilities = computeWarehouseCapabilities(installed, warehouseLayout)
-        if (capabilities.loaders) info.loaders = capabilities.loaders
-
-        const totalBonus = computeStorageBonus(installed, state.capacity)
-        info.capacity = UInt32.from(state.capacity + totalBonus)
-    } else {
-        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
-    }
-
-    info.modules = moduleEntries
-
-    const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Warehouse(entityInfo)
-}
 
-export function makeExtractor(state: ExtractorStateInput): Extractor {
-    const info: Record<string, unknown> = {
-        type: Name.from('extractor'),
-        id: UInt64.from(state.id),
-        owner: Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        cargomass: UInt32.from(0),
-        cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
-    }
-    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
     if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
     if (state.schedule) info.schedule = state.schedule
-    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
 
-    const moduleEntries = assignModulesToSlots(
-        ITEM_EXTRACTOR_T1_PACKED,
-        state.modules ?? [],
-        'Extractor T1'
-    )
-    if (state.modules && state.modules.length > 0) {
-        const layout = getEntityLayout(ITEM_EXTRACTOR_T1_PACKED)?.slots ?? []
-        const installed = toInstalledModules(moduleEntries)
-        const capabilities = computeExtractorCapabilities(installed, layout)
-        if (capabilities.generator) info.generator = capabilities.generator
-        if (capabilities.gatherer) info.gatherer = capabilities.gatherer
-    }
+    if (kind === 'container') {
+        info.modules = []
+        if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
+        if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+    } else {
+        const entityLabel = getKindMeta(template.kind)?.defaultLabel ?? kind
+        const moduleEntries = assignModulesToSlots(layout, mods, entityLabel)
+        info.modules = moduleEntries
 
-    info.modules = moduleEntries
+        const installed = toInstalledModules(moduleEntries)
+        const caps = computeEntityCapabilities(ZERO_HULL_STATS, packedItemId, installed, layout)
 
-    const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Extractor(entityInfo)
-}
+        if (state.hullmass !== undefined) {
+            info.hullmass = UInt32.from(state.hullmass)
+        } else if (installed.length > 0) {
+            info.hullmass = UInt32.from(caps.hullmass)
+        }
 
-export function makeFactory(state: FactoryStateInput): Factory {
-    const info: Record<string, unknown> = {
-        type: Name.from('factory'),
-        id: UInt64.from(state.id),
-        owner: Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        cargomass: UInt32.from(0),
-        cargo: state.cargo || [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
-    }
-    if (state.hullmass !== undefined) info.hullmass = UInt32.from(state.hullmass)
-    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
-    if (state.schedule) info.schedule = state.schedule
-    if (state.capacity !== undefined) info.capacity = UInt32.from(state.capacity)
+        if (state.capacity !== undefined) {
+            info.capacity = UInt32.from(state.capacity)
+        } else {
+            info.capacity = UInt32.from(caps.capacity)
+        }
 
-    const moduleEntries = assignModulesToSlots(
-        ITEM_FACTORY_T1_PACKED,
-        state.modules ?? [],
-        'Factory T1'
-    )
-    if (state.modules && state.modules.length > 0) {
-        const layout = getEntityLayout(ITEM_FACTORY_T1_PACKED)?.slots ?? []
-        const installed = toInstalledModules(moduleEntries)
-        const capabilities = computeFactoryCapabilities(installed, layout)
-        if (capabilities.generator) info.generator = capabilities.generator
-        if (capabilities.crafter) info.crafter = capabilities.crafter
+        if (caps.engines) info.engines = caps.engines
+        if (caps.generator) info.generator = caps.generator
+        if (caps.gatherer) info.gatherer = caps.gatherer
+        if (caps.loaders) info.loaders = caps.loaders
+        if (caps.crafter) info.crafter = caps.crafter
+        if (caps.hauler) info.hauler = caps.hauler
+        if (caps.warp) info.warp = caps.warp
     }
 
-    info.modules = moduleEntries
-
     const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Factory(entityInfo)
-}
-
-export function makeContainer(state: ContainerStateInput): Container {
-    const entityInfo = ServerContract.Types.entity_info.from({
-        type: Name.from('container'),
-        id: UInt64.from(state.id),
-        owner: Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        hullmass: UInt32.from(state.hullmass),
-        capacity: UInt32.from(state.capacity),
-        cargomass: UInt32.from(state.cargomass || 0),
-        cargo: state.cargo || [],
-        modules: [],
-        is_idle: !state.schedule,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
-        schedule: state.schedule,
-    })
-    return new Container(entityInfo)
-}
-
-export function makeNexus(state: NexusStateInput): Nexus {
-    const entityInfo = ServerContract.Types.entity_info.from({
-        type: Name.from('nexus'),
-        id: UInt64.from(state.id),
-        owner: Name.from(state.owner),
-        entity_name: state.name,
-        coordinates: ServerContract.Types.coordinates.from(state.coordinates),
-        cargomass: UInt32.from(0),
-        cargo: [],
-        modules: [],
-        is_idle: true,
-        current_task_elapsed: UInt32.from(0),
-        current_task_remaining: UInt32.from(0),
-        pending_tasks: [],
-    })
-    return new Nexus(entityInfo)
+    return new Entity(entityInfo)
 }

package/src/index-module.ts

@@ -10,28 +10,19 @@ export {Types as ServerTypes} from './contracts/server'
 export {Types as PlatformTypes} from './contracts/platform'
 
 import type {ServerContract} from './contracts'
+import type {Entity as EntityType} from './entities/entity'
 
 export {Shipload} from './shipload'
-export {Ship} from './entities/ship'
-export type {ShipStateInput, PackedModuleInput} from './entities/ship'
-export {Warehouse, computeWarehouseCapabilities} from './entities/warehouse'
-export type {WarehouseStateInput} from './entities/warehouse'
-export {Extractor, computeExtractorCapabilities} from './entities/extractor'
-export type {ExtractorStateInput, ExtractorCapabilities} from './entities/extractor'
-export {Factory, computeFactoryCapabilities} from './entities/factory'
-export type {FactoryStateInput, FactoryCapabilities} from './entities/factory'
-export {Container} from './entities/container'
-export type {ContainerStateInput} from './entities/container'
-export {Nexus} from './entities/nexus'
-export type {NexusStateInput} from './entities/nexus'
-export {
-    makeShip,
-    makeWarehouse,
-    makeExtractor,
-    makeFactory,
-    makeContainer,
-    makeNexus,
-} from './entities/makers'
+export {Entity} from './entities/entity'
+export type Ship = EntityType
+export type Warehouse = EntityType
+export type Container = EntityType
+export type Extractor = EntityType
+export type Factory = EntityType
+export type Nexus = EntityType
+export {makeEntity} from './entities/makers'
+export type {EntityStateInput, PackedModuleInput} from './entities/makers'
+export type {InstalledModule} from './entities/slot-multiplier'
 
 export type movement_stats = ServerContract.Types.movement_stats
 export type energy_stats = ServerContract.Types.energy_stats
@@ -57,7 +48,7 @@ export {
     EpochsManager,
     ActionsManager,
 } from './managers'
-export type {EntityType, LocationStratum} from './managers'
+export type {LocationStratum} from './managers'
 export type {EntityRefInput} from './managers/actions'
 
 export {
@@ -203,21 +194,24 @@ export {
     ENTITY_EXTRACTOR,
     ENTITY_FACTORY,
     ENTITY_CONTAINER,
-    shipTraits,
-    warehouseTraits,
-    extractorTraits,
-    factoryTraits,
-    containerTraits,
+    ENTITY_NEXUS,
     getEntityClass,
     getPackedEntityType,
-    getEntityTraits,
+    getKindMeta,
+    getTemplateMeta,
+    kindCan,
+    CAP_WRAP,
+    CAP_UNDEPLOY,
+    CAP_DEMOLISH,
+    CAP_MODULES,
     isShip,
     isWarehouse,
     isExtractor,
     isFactory,
     isContainer,
-} from './types/entity-traits'
-export type {EntityTraits, EntityTypeName} from './types/entity-traits'
+    isNexus,
+} from './data/kind-registry'
+export type {EntityTypeName, KindMeta, TemplateMeta} from './data/kind-registry'
 export * from './capabilities'
 
 export {
@@ -274,8 +268,6 @@ export {
 } from './derivation/crafting'
 export type {StackInput, CategoryStacks, RecipeSlotInput} from './derivation/crafting'
 
-export {computeContainerCapabilities, computeContainerT2Capabilities} from './entities/container'
-
 export {
     computeShipHullCapabilities,
     computeEngineCapabilities,
@@ -286,12 +278,16 @@ export {
     computeCrafterCapabilities,
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
-    computeShipCapabilities,
+    computeContainerCapabilities,
+    computeContainerT2Capabilities,
+    computeWarpCapabilities,
+    computeBaseCapacity,
+    computeEntityCapabilities,
     GATHERER_DEPTH_TABLE,
     GATHERER_DEPTH_MAX_TIER,
     gathererDepthForTier,
-} from './entities/ship-deploy'
-export type {ShipCapabilities, GathererDepthParams} from './entities/ship-deploy'
+} from './derivation/capabilities'
+export type {GathererDepthParams, ComputedCapabilities} from './derivation/capabilities'
 
 export {resolveItem} from './resolution/resolve-item'
 export type {

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 {