@shipload/sdk 1.0.0-next.4 → 1.0.0-next.41

package/src/entities/makers.ts

@@ -1,42 +1,57 @@
 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 {ITEM_SHIP_T1_PACKED, ITEM_WAREHOUSE_T1_PACKED} from '../data/item-ids'
+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 {decodeCraftedItemStats} from '../derivation/crafting'
+import {getModuleCapabilityType, moduleAccepts, moduleSlotTypeToCode} from '../capabilities/modules'
+import {computeEntityCapabilities} from '../derivation/capabilities'
+import {packedModulesToInstalled} from './slot-multiplier'
+import {LANE_MOBILITY} from '../scheduling/schedule'
+
+export interface PackedModuleInput {
+    itemId: number
+    stats: bigint
+}
+
+export interface EntityStateInput {
+    id: UInt64Type
+    owner: NameType
+    name: string
+    coordinates: {x: number; y: number; z?: number}
+    itemId?: number
+    hullmass?: number
+    capacity?: number
+    cargomass?: number
+    energy?: number
+    modules?: PackedModuleInput[]
+    schedule?: ServerContract.Types.schedule
+    lanes?: ServerContract.Types.lane[]
+    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}`
@@ -56,141 +71,116 @@ function assignModulesToSlots(
     )
 }
 
-function decodePackedInput(m: PackedModuleInput): {itemId: number; stats: bigint} {
-    return {
-        itemId: Number(UInt16.from(m.itemId).value.toString()),
-        stats: BigInt(UInt64.from(m.stats).toString()),
-    }
+const ZERO_HULL_STATS: Record<string, number> = {
+    density: 0,
+    strength: 0,
+    hardness: 0,
+    cohesion: 0,
 }
 
-function computeStorageBonus(
-    decoded: {itemId: number; stats: bigint}[],
-    baseCapacity: number
-): number {
-    let totalBonus = 0
-    for (const m of decoded) {
-        if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
-        const stats = decodeCraftedItemStats(m.itemId, m.stats)
-        const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
-        totalBonus += capacityBonus
+export function makeEntity(packedItemId: number, state: EntityStateInput): Entity {
+    const template = getTemplateMeta(packedItemId)
+    if (!template) {
+        throw new Error(`Unknown packed entity item ID: ${packedItemId}`)
     }
-    return totalBonus
-}
 
-function deriveShipFromModules(
-    modules: PackedModuleInput[],
-    baseCapacity: number
-): {
-    capabilities: ReturnType<typeof computeShipCapabilities>
-    finalCapacity: number
-} {
-    const decoded = modules.map(decodePackedInput)
-    const capabilities = computeShipCapabilities(decoded)
-    const totalBonus = computeStorageBonus(decoded, baseCapacity)
-    return {capabilities, finalCapacity: baseCapacity + totalBonus}
-}
+    const kind = template.kind.toString() as EntityTypeName
+    const layout = getEntityLayout(packedItemId)?.slots ?? []
+    const mods = state.modules ?? []
+
+    const lanes =
+        state.lanes ??
+        (state.schedule
+            ? [
+                  ServerContract.Types.lane.from({
+                      lane_key: UInt8.from(LANE_MOBILITY),
+                      schedule: state.schedule,
+                  }),
+              ]
+            : [])
 
-export function makeShip(state: ShipStateInput): Ship {
     const info: Record<string, unknown> = {
-        type: Name.from('ship'),
+        type: template.kind,
         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),
+        item_id: UInt16.from(state.itemId ?? template.itemId),
+        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: [],
+        lanes,
+        holds: [],
     }
-    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[] = []
-    if (state.modules && state.modules.length > 0) {
-        moduleEntries = assignModulesToSlots(ITEM_SHIP_T1_PACKED, state.modules, 'Ship T1')
-        const {capabilities, finalCapacity} = deriveShipFromModules(
-            state.modules,
-            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 (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 = packedModulesToInstalled(moduleEntries)
+        const caps = computeEntityCapabilities(ZERO_HULL_STATS, packedItemId, installed, layout)
 
-    const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Ship(entityInfo)
-}
+        if (state.hullmass !== undefined) {
+            info.hullmass = UInt32.from(state.hullmass)
+        } else if (installed.length > 0) {
+            info.hullmass = UInt32.from(caps.hullmass)
+        }
 
-export function makeWarehouse(state: WarehouseStateInput): Warehouse {
-    const info: Record<string, unknown> = {
-        type: Name.from('warehouse'),
-        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),
-        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[] = []
-    if (state.modules && state.modules.length > 0) {
-        moduleEntries = assignModulesToSlots(
-            ITEM_WAREHOUSE_T1_PACKED,
-            state.modules,
-            'Warehouse T1'
-        )
-        const decoded = state.modules.map(decodePackedInput)
-        const capabilities = computeWarehouseCapabilities(decoded)
-        if (capabilities.loaders) info.loaders = capabilities.loaders
+        if (state.capacity !== undefined) {
+            info.capacity = UInt32.from(state.capacity)
+        } else {
+            info.capacity = UInt32.from(caps.capacity)
+        }
 
-        const totalBonus = computeStorageBonus(decoded, state.capacity)
-        info.capacity = UInt32.from(state.capacity + totalBonus)
-    } else {
-        moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
+        if (caps.engines) info.engines = caps.engines
+        if (caps.generator) info.generator = caps.generator
+        if (caps.hauler) info.hauler = caps.hauler
+        if (caps.warp) info.warp = caps.warp
+        if (caps.launcher) {
+            info.launcher = ServerContract.Types.launcher_stats.from({
+                charge_rate: caps.launcher.chargeRate,
+                velocity: caps.launcher.velocity,
+                drain: caps.launcher.drain,
+            })
+        }
+
+        info.gatherer_lanes = (caps.gathererLanes ?? []).map((l) =>
+            ServerContract.Types.gatherer_lane.from({
+                slot_index: l.slotIndex,
+                yield: l.yield,
+                drain: l.drain,
+                depth: l.depth,
+                output_pct: l.outputPct,
+            })
+        )
+        info.crafter_lanes = (caps.crafterLanes ?? []).map((l) =>
+            ServerContract.Types.crafter_lane.from({
+                slot_index: l.slotIndex,
+                speed: l.speed,
+                drain: l.drain,
+                output_pct: l.outputPct,
+            })
+        )
+        info.loader_lanes = (caps.loaderLanes ?? []).map((l) =>
+            ServerContract.Types.loader_lane.from({
+                slot_index: l.slotIndex,
+                mass: l.mass,
+                thrust: l.thrust,
+                output_pct: l.outputPct,
+            })
+        )
     }
 
-    info.modules = moduleEntries
+    if (!info.gatherer_lanes) info.gatherer_lanes = []
+    if (!info.crafter_lanes) info.crafter_lanes = []
+    if (!info.loader_lanes) info.loader_lanes = []
 
     const entityInfo = ServerContract.Types.entity_info.from(info)
-    return new Warehouse(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/entities/slot-multiplier.ts

@@ -0,0 +1,43 @@
+import type {EntitySlot} from '../data/recipes-runtime'
+import type {ServerContract} from '../contracts'
+
+export const U16_MAX = 65535
+
+export interface InstalledModule {
+    slotIndex: number
+    itemId: number
+    stats: bigint
+}
+
+export function packedModulesToInstalled(
+    entries: ServerContract.Types.module_entry[]
+): InstalledModule[] {
+    const installed: InstalledModule[] = []
+    entries.forEach((entry, slotIndex) => {
+        if (!entry.installed) return
+        installed.push({
+            slotIndex,
+            itemId: Number(entry.installed.item_id.value),
+            stats: BigInt(entry.installed.stats.toString()),
+        })
+    })
+    return installed
+}
+
+export function clampUint16(value: number): number {
+    return Math.min(value, U16_MAX)
+}
+
+export const clampUint32 = (v: number): number => Math.min(Math.max(Math.floor(v), 0), 4294967295)
+
+export function applySlotMultiplier(value: number, outputPct: number): number {
+    return clampUint16(Math.floor((value * outputPct) / 100))
+}
+
+export function applySlotMultiplierUint32(value: number, outputPct: number): number {
+    return clampUint32(Math.floor((value * outputPct) / 100))
+}
+
+export function getSlotAmp(layout: EntitySlot[], slotIndex: number): number {
+    return layout[slotIndex]?.outputPct ?? 100
+}

package/src/errors.ts

@@ -16,20 +16,18 @@ export const REQUIRES_POSITIVE_VALUE = 'Value must be greater than zero.'
 export const PLAYER_ALREADY_JOINED = 'Player has already joined the game.'
 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,19 +36,15 @@ 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.'
 export const GROUP_EMPTY = 'Group travel requires at least one entity.'
 export const GROUP_NO_THRUST = 'Group travel requires at least one entity with engines.'
 export const GROUP_NOT_SAME_LOCATION = 'All entities must be at the same location for group travel.'
@@ -62,6 +56,8 @@ export const GROUP_HAUL_CAPACITY_EXCEEDED =
     'Group travel requires sufficient hauler capacity for all non-self-propelled entities.'
 export const CANCEL_CONTAINS_GROUPED_TASK =
     'Cannot cancel range containing grouped task - cancel non-grouped tasks first.'
+export const WOULD_STRAND = 'Cancelling this would leave a later task without the cargo it needs.'
+export const WOULD_OVERFILL = 'Cancelling this would overfill the other entity with returned cargo.'
 export const WARP_NO_CAPABILITY = 'Entity does not have warp capability.'
 export const WARP_HAS_SCHEDULE = 'Entity must be idle to warp.'
 export const WARP_HAS_CARGO = 'Entity must have no cargo to warp.'

package/src/format.ts

@@ -1,8 +1,12 @@
 export function formatMass(kg: number): string {
-    const t = kg / 1000
-    const fixed = t.toFixed(2)
-    const trimmed = fixed.replace(/\.?0+$/, '')
-    return `${trimmed} t`
+    if (kg === 0) return '0 t'
+    const sign = kg < 0 ? '-' : ''
+    const centitonnes = Math.round(Math.abs(kg) / 10)
+    const t = Math.floor(centitonnes / 100)
+    const frac = centitonnes % 100
+    if (frac === 0) return `${sign}${t} t`
+    const fracStr = String(frac).padStart(2, '0').replace(/0$/, '')
+    return `${sign}${t}.${fracStr} t`
 }
 
 export function formatMassDelta(kg: number): string {
@@ -10,3 +14,21 @@ export function formatMassDelta(kg: number): string {
     const sign = kg > 0 ? '+' : '-'
     return `${sign}${formatMass(Math.abs(kg))}`
 }
+
+export function formatLocation(loc: {x: number; y: number}): string {
+    return `${loc.x}, ${loc.y}`
+}
+
+function trim(n: number, digits = 1): string {
+    return n.toFixed(digits).replace(/\.?0+$/, '')
+}
+
+export function formatMassScaled(kg: number): string {
+    if (kg === 0) return '0 t'
+    const sign = kg < 0 ? '-' : ''
+    const tonnes = Math.abs(kg) / 1000
+    if (tonnes >= 1_000_000_000) return `${sign}${trim(tonnes / 1_000_000_000)}b t`
+    if (tonnes >= 1_000_000) return `${sign}${trim(tonnes / 1_000_000)}m t`
+    if (tonnes >= 1_000) return `${sign}${trim(tonnes / 1_000)}k t`
+    return formatMass(kg)
+}