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

package/src/entities/makers.ts

@@ -1,48 +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 {Extractor, computeExtractorCapabilities, type ExtractorStateInput} from './extractor'
-import {
-    ITEM_EXTRACTOR_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}`
@@ -68,180 +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
+const ZERO_HULL_STATS: Record<string, number> = {
+    density: 0,
+    strength: 0,
+    hardness: 0,
+    saturation: 0,
 }
 
-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}
-}
-
-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
+    if (state.energy !== undefined) info.energy = UInt16.from(state.energy)
+    if (state.schedule) info.schedule = state.schedule
 
-        const totalBonus = computeStorageBonus(installed, state.capacity)
-        info.capacity = UInt32.from(state.capacity + totalBonus)
+    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 {
-        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
-    }
+        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 Warehouse(entityInfo)
-}
+        if (state.hullmass !== undefined) {
+            info.hullmass = UInt32.from(state.hullmass)
+        } else if (installed.length > 0) {
+            info.hullmass = UInt32.from(caps.hullmass)
+        }
 
-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)
+        if (state.capacity !== undefined) {
+            info.capacity = UInt32.from(state.capacity)
+        } else {
+            info.capacity = UInt32.from(caps.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 (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 Extractor(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)
+    return new Entity(entityInfo)
 }

package/src/errors.ts

@@ -18,18 +18,18 @@ export const PLAYER_NOT_JOINED = 'Player has not joined the game.'
 export const PLAYER_NOT_FOUND = 'Cannot find player for given account name.'
 export const STARTER_ALREADY_CLAIMED =
     'Starter ship already claimed; destroy existing ships to re-claim.'
-export const SHIP_ALREADY_THERE = 'Ship cannot travel to the location its already at.'
+export const ENTITY_ALREADY_THERE = 'Entity cannot travel to the location it is already at.'
 export const SHIP_ALREADY_TRAVELING = 'Ship is already traveling.'
 export const SHIP_CANNOT_BUY_TRAVELING = 'Ship cannot buy goods while traveling.'
 export const SHIP_CANNOT_UPDATE_TRAVELING = 'Ship cannot be updated while traveling.'
-export const SHIP_INVALID_DESTINATION = 'Ship cannot travel, no system at specified destination.'
-export const SHIP_INVALID_TRAVEL_DURATION =
+export const ENTITY_INVALID_DESTINATION = 'Cannot travel: no system at specified destination.'
+export const ENTITY_INVALID_TRAVEL_DURATION =
     'This trip cannot be made as it would exceed the maximum travel duration.'
 export const SHIP_NOT_ARRIVED = 'Ship has not yet arrived at its destination.'
-export const SHIP_NOT_ENOUGH_ENERGY =
-    'Ship does not have enough energy to travel to the destination.'
-export const SHIP_NOT_ENOUGH_ENERGY_CAPACITY =
-    'Ship does not have enough energy capacity to travel.'
+export const ENTITY_NOT_ENOUGH_ENERGY =
+    'Entity does not have enough energy to travel to the destination.'
+export const ENTITY_NOT_ENOUGH_ENERGY_CAPACITY =
+    'Entity does not have enough energy capacity to travel.'
 export const SHIP_NOT_FOUND = 'Cannot find ship for given account.'
 export const SHIP_NOT_OWNED = 'Ship is not owned by this account.'
 export const NO_SCHEDULE = 'No scheduled tasks.'
@@ -38,16 +38,13 @@ export const SHIP_NO_COMPLETED_TASKS = 'No completed tasks to resolve.'
 export const RESOLVE_COUNT_EXCEEDS_COMPLETED = 'Requested resolve count exceeds completed tasks.'
 export const SHIP_CANNOT_CANCEL_TASK = 'Cannot cancel task that is immutable or in progress.'
 export const SHIP_NO_TASKS_TO_CANCEL = 'No tasks to cancel.'
-export const SHIP_INVALID_CARGO = 'Invalid cargo specified for load/unload.'
-export const SHIP_CARGO_NOT_OWNED = 'Cannot load cargo that is not owned.'
-export const SHIP_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
-export const SHIP_CAPACITY_EXCEEDED = 'Ship cargo capacity would be exceeded.'
+export const ENTITY_INVALID_CARGO = 'Invalid cargo specified for load/unload.'
+export const ENTITY_CARGO_NOT_OWNED = 'Cannot load cargo that is not owned.'
+export const ENTITY_CARGO_NOT_LOADED = 'Cannot unload cargo that is not loaded.'
 export const ENTITY_CAPACITY_EXCEEDED = 'Entity cargo capacity would be exceeded.'
 export const WAREHOUSE_NOT_FOUND = 'Cannot find warehouse for given id.'
 export const WAREHOUSE_ALREADY_AT_LOCATION = 'Warehouse already exists at this location.'
-export const WAREHOUSE_CAPACITY_EXCEEDED = 'Warehouse capacity would be exceeded.'
 export const CONTAINER_NOT_FOUND = 'Cannot find container for given id.'
-export const CONTAINER_CAPACITY_EXCEEDED = 'Container capacity would be exceeded.'
 export const DESTINATION_CAPACITY_EXCEEDED =
     'Destination entity does not have enough capacity for the gather.'
 export const CANCEL_PAIRED_HAS_PENDING = 'Cannot cancel transfer, paired entity has pending tasks.'

package/src/index-module.ts

@@ -10,17 +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 {Container} from './entities/container'
-export type {ContainerStateInput} from './entities/container'
-export {makeShip, makeWarehouse, makeExtractor, makeContainer} 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
@@ -46,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 {
@@ -190,20 +192,26 @@ export {
     ENTITY_SHIP,
     ENTITY_WAREHOUSE,
     ENTITY_EXTRACTOR,
+    ENTITY_FACTORY,
     ENTITY_CONTAINER,
-    shipTraits,
-    warehouseTraits,
-    extractorTraits,
-    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 {
@@ -260,8 +268,6 @@ export {
 } from './derivation/crafting'
 export type {StackInput, CategoryStacks, RecipeSlotInput} from './derivation/crafting'
 
-export {computeContainerCapabilities, computeContainerT2Capabilities} from './entities/container'
-
 export {
     computeShipHullCapabilities,
     computeEngineCapabilities,
@@ -272,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 {
@@ -359,3 +369,10 @@ export {displayName, describeItem} from './resolution/display-name'
 export type {DescribeOptions} from './resolution/display-name'
 
 export * from './subscriptions'
+
+export {assertProjectionEquals} from './testing/projection-parity'
+export type {
+    ContractProjectedState,
+    ProjectionComparisonOptions,
+} from './testing/projection-parity'
+export {CATALOG_FILES_REL, computeCatalogHash} from './testing/catalog-hash'

package/src/managers/entities.ts

@@ -1,113 +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 {Entity} from '../entities/entity'
+import type {EntityTypeName} from '../data/kind-registry'
 import type {ServerContract} from '../contracts'
 
-export type EntityType = 'ship' | 'warehouse' | 'extractor' | 'container'
+export type {EntityTypeName} from '../data/kind-registry'
 
 export class EntitiesManager extends BaseManager {
-    async getEntity(id: UInt64Type): Promise<Ship | Warehouse | Extractor | Container> {
+    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 | Container)[]> {
+        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 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 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')
-    }
-
-    private wrapEntity(
-        entity: ServerContract.Types.entity_info
-    ): Ship | Warehouse | Extractor | Container {
-        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('container')) return new Container(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

@@ -96,10 +96,15 @@ export function deserializeAtomicData(
             case 'uint64':
                 result[field.name] = readVarint64()
                 break
+            case 'int32':
+                result[field.name] = readZigzagInt64()
+                break
             case 'int64':
                 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,