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

package/src/entities/ship-deploy.ts

@@ -8,17 +8,22 @@ import {
     MODULE_HAULER,
     MODULE_LOADER,
 } from '../capabilities/modules'
+import {getItem} from '../data/catalog'
+import type {EntitySlot} from '../data/recipes-runtime'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+
+export type {InstalledModule}
 
 export function computeShipHullCapabilities(stats: Record<string, number>): {
     hullmass: number
     capacity: number
 } {
-    const density = stats.density ?? 500
-    const strength = stats.strength ?? 500
-    const hardness = stats.hardness ?? 500
-    const saturation = stats.saturation ?? 500
+    const density = stats.density
+    const strength = stats.strength
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const hullmass = 25000 + 75 * density
+    const hullmass = 100000 - 75 * density
     const statSum = strength + hardness + saturation
     const exponent = statSum / 2997.0
     const capacity = Math.floor(1000000 * 10 ** exponent)
@@ -30,8 +35,8 @@ export function computeEngineCapabilities(stats: Record<string, number>): {
     thrust: number
     drain: number
 } {
-    const vol = stats.volatility ?? 500
-    const thm = stats.thermal ?? 500
+    const vol = stats.volatility
+    const thm = stats.thermal
 
     return {
         thrust: 400 + Math.floor((vol * 3) / 4),
@@ -43,30 +48,61 @@ export function computeGeneratorCapabilities(stats: Record<string, number>): {
     capacity: number
     recharge: number
 } {
-    const res = stats.resonance ?? 500
-    const ref = stats.reflectivity ?? 500
+    const com = stats.composition
+    const fin = stats.fineness
 
     return {
-        capacity: 300 + Math.floor(res / 6),
-        recharge: 1 + Math.floor((ref * 3) / 1000),
+        capacity: 300 + Math.floor(com / 6),
+        recharge: 1 + Math.floor((fin * 3) / 1000),
+    }
+}
+
+export interface GathererDepthParams {
+    readonly floor: number
+    readonly slope: number
+}
+
+export const GATHERER_DEPTH_TABLE: readonly GathererDepthParams[] = [
+    {floor: 500, slope: 5},
+    {floor: 2000, slope: 11},
+    {floor: 7000, slope: 16},
+    {floor: 15000, slope: 18},
+    {floor: 25000, slope: 19},
+    {floor: 35000, slope: 16},
+    {floor: 46000, slope: 12},
+    {floor: 53500, slope: 10},
+    {floor: 60000, slope: 5},
+    {floor: 63500, slope: 2},
+]
+
+export const GATHERER_DEPTH_MAX_TIER = 10
+
+export function gathererDepthForTier(tol: number, tier: number): number {
+    if (tier < 1 || tier > GATHERER_DEPTH_MAX_TIER) {
+        throw new Error(`gatherer tier out of range: ${tier}`)
     }
+    const p = GATHERER_DEPTH_TABLE[tier - 1]
+    return p.floor + tol * p.slope
 }
 
-export function computeGathererCapabilities(stats: Record<string, number>): {
+export function computeGathererCapabilities(
+    stats: Record<string, number>,
+    tier: number
+): {
     yield: number
     drain: number
     depth: number
     speed: number
 } {
-    const str = stats.strength ?? 500
-    const con = stats.conductivity ?? 500
-    const ref = stats.reflectivity ?? 500
-    const tol = stats.tolerance ?? 500
+    const str = stats.strength
+    const con = stats.conductivity
+    const ref = stats.reflectivity
+    const tol = stats.tolerance
 
     return {
         yield: 200 + str,
         drain: Math.max(250, 1250 - Math.floor((con * 25) / 20)),
-        depth: 200 + Math.floor((tol * 3) / 2),
+        depth: gathererDepthForTier(tol, tier),
         speed: 100 + Math.floor((ref * 4) / 5),
     }
 }
@@ -76,12 +112,12 @@ export function computeLoaderCapabilities(stats: Record<string, number>): {
     thrust: number
     quantity: number
 } {
-    const hrd = stats.hardness ?? 500
-    const pla = stats.plasticity ?? 500
+    const insulation = stats.insulation
+    const plasticity = stats.plasticity
 
     return {
-        mass: Math.max(200, 2000 - Math.floor(hrd * 2)),
-        thrust: 1 + Math.floor(pla / 500),
+        mass: Math.max(200, 2000 - Math.floor(insulation * 2)),
+        thrust: 1 + Math.floor(plasticity / 500),
         quantity: 1,
     }
 }
@@ -90,12 +126,12 @@ export function computeCrafterCapabilities(stats: Record<string, number>): {
     speed: number
     drain: number
 } {
-    const rea = stats.reactivity ?? 500
-    const com = stats.composition ?? 500
+    const rea = stats.reactivity
+    const fin = stats.fineness
 
     return {
         speed: 100 + Math.floor((rea * 4) / 5),
-        drain: Math.max(5, 30 - Math.floor(com / 33)),
+        drain: Math.max(5, 30 - Math.floor(fin / 33)),
     }
 }
 
@@ -104,14 +140,14 @@ export function computeHaulerCapabilities(stats: Record<string, number>): {
     efficiency: number
     drain: number
 } {
-    const res = stats.resonance ?? 500
-    const con = stats.conductivity ?? 500
-    const ref = stats.reflectivity ?? 500
+    const fineness = stats.fineness
+    const conductivity = stats.conductivity
+    const composition = stats.composition
 
     return {
-        capacity: Math.max(1, 1 + Math.floor(res / 400)),
-        efficiency: 2000 + con * 6,
-        drain: Math.max(3, 15 - Math.floor(ref / 80)),
+        capacity: Math.max(1, 1 + Math.floor(fineness / 400)),
+        efficiency: 2000 + conductivity * 6,
+        drain: Math.max(3, 15 - Math.floor(composition / 80)),
     }
 }
 
@@ -121,11 +157,12 @@ export function computeStorageCapabilities(
 ): {
     capacityBonus: number
 } {
-    const strength = stats.strength ?? 500
-    const hardness = stats.hardness ?? 500
-    const saturation = stats.saturation ?? 500
+    const strength = stats.strength
+    const density = stats.density
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const statSum = strength + hardness + saturation
+    const statSum = strength + density + hardness + saturation
     const capacityBonus = Math.floor(
         (baseCapacity * (10 + Math.floor((statSum * 10) / 2997))) / 100
     )
@@ -137,12 +174,12 @@ export function computeWarehouseHullCapabilities(stats: Record<string, number>):
     hullmass: number
     capacity: number
 } {
-    const density = stats.density ?? 500
-    const strength = stats.strength ?? 500
-    const hardness = stats.hardness ?? 500
-    const saturation = stats.saturation ?? 500
+    const density = stats.density
+    const strength = stats.strength
+    const hardness = stats.hardness
+    const saturation = stats.saturation
 
-    const hullmass = 25000 + 75 * density
+    const hullmass = 100000 - 75 * density
     const statSum = strength + hardness + saturation
     const exponent = statSum / 2997.0
     const capacity = Math.floor(20000000 * 10 ** exponent)
@@ -160,7 +197,8 @@ export interface ShipCapabilities {
 }
 
 export function computeShipCapabilities(
-    modules: {itemId: number; stats: bigint}[]
+    modules: InstalledModule[],
+    layout: EntitySlot[]
 ): ShipCapabilities {
     const ship: ShipCapabilities = {}
 
@@ -170,7 +208,7 @@ export function computeShipCapabilities(
         let totalDrain = 0
         for (const m of engineModules) {
             const caps = computeEngineCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalDrain += caps.drain
         }
         ship.engines = {thrust: totalThrust, drain: totalDrain}
@@ -184,10 +222,14 @@ export function computeShipCapabilities(
         let totalRecharge = 0
         for (const m of generatorModules) {
             const caps = computeGeneratorCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalCapacity += caps.capacity
-            totalRecharge += caps.recharge
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalCapacity += applySlotMultiplier(caps.capacity, amp)
+            totalRecharge += applySlotMultiplier(caps.recharge, amp)
+        }
+        ship.generator = {
+            capacity: clampUint16(totalCapacity),
+            recharge: clampUint16(totalRecharge),
         }
-        ship.generator = {capacity: totalCapacity, recharge: totalRecharge}
     }
 
     const gathererModules = modules.filter(
@@ -196,16 +238,26 @@ export function computeShipCapabilities(
     if (gathererModules.length > 0) {
         let totalYield = 0
         let totalDrain = 0
-        let totalDepth = 0
+        let maxDepth = 0
         let totalSpeed = 0
         for (const m of gathererModules) {
-            const caps = computeGathererCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalYield += caps.yield
+            const tier = getItem(m.itemId).tier
+            const caps = computeGathererCapabilities(
+                decodeCraftedItemStats(m.itemId, m.stats),
+                tier
+            )
+            const amp = getSlotAmp(layout, m.slotIndex)
+            totalYield += applySlotMultiplier(caps.yield, amp)
             totalDrain += caps.drain
-            totalDepth += caps.depth
-            totalSpeed += caps.speed
+            if (caps.depth > maxDepth) maxDepth = caps.depth
+            totalSpeed += applySlotMultiplier(caps.speed, amp)
+        }
+        ship.gatherer = {
+            yield: clampUint16(totalYield),
+            drain: totalDrain,
+            depth: maxDepth,
+            speed: clampUint16(totalSpeed),
         }
-        ship.gatherer = {yield: totalYield, drain: totalDrain, depth: totalDepth, speed: totalSpeed}
     }
 
     const haulerModules = modules.filter((m) => getModuleCapabilityType(m.itemId) === MODULE_HAULER)
@@ -215,13 +267,15 @@ export function computeShipCapabilities(
         let totalDrain = 0
         for (const m of haulerModules) {
             const caps = computeHaulerCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
+            const eff = applySlotMultiplier(caps.efficiency, getSlotAmp(layout, m.slotIndex))
             totalCapacity += caps.capacity
-            weightedEffNum += caps.efficiency * caps.capacity
+            weightedEffNum += eff * caps.capacity
             totalDrain += caps.drain
         }
+        const efficiency = totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0
         ship.hauler = {
             capacity: totalCapacity,
-            efficiency: totalCapacity > 0 ? Math.floor(weightedEffNum / totalCapacity) : 0,
+            efficiency: clampUint16(efficiency),
             drain: totalDrain,
         }
     }
@@ -234,10 +288,14 @@ export function computeShipCapabilities(
         for (const m of loaderModules) {
             const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalQuantity += caps.quantity
         }
-        ship.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+        ship.loaders = {
+            mass: totalMass,
+            thrust: clampUint16(totalThrust),
+            quantity: totalQuantity,
+        }
     }
 
     const crafterModules = modules.filter(
@@ -248,10 +306,10 @@ export function computeShipCapabilities(
         let totalDrain = 0
         for (const m of crafterModules) {
             const caps = computeCrafterCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
-            totalSpeed += caps.speed
+            totalSpeed += applySlotMultiplier(caps.speed, getSlotAmp(layout, m.slotIndex))
             totalDrain += caps.drain
         }
-        ship.crafter = {speed: totalSpeed, drain: totalDrain}
+        ship.crafter = {speed: clampUint16(totalSpeed), drain: totalDrain}
     }
 
     return ship

package/src/entities/ship.ts

@@ -2,7 +2,9 @@ import {type UInt16, type UInt16Type, UInt32, UInt64, type UInt64Type} from '@wh
 import {ServerContract} from '../contracts'
 import {Coordinates, type CoordinatesType} from '../types'
 import {
+    type FloatPosition,
     getDestinationLocation,
+    getInterpolatedPosition,
     getPositionAt,
     getFlightOrigin as travelGetFlightOrigin,
 } from '../travel/travel'
@@ -55,6 +57,14 @@ export class Ship extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'mobile' {
+        return 'mobile'
+    }
+
+    get canUndeploy(): boolean {
+        return true
+    }
+
     get inv(): InventoryAccessor {
         this._inv ??= new InventoryAccessor(this)
         return this._inv
@@ -87,12 +97,19 @@ export class Ship extends ServerContract.Types.entity_info {
         return dest ? Coordinates.from(dest) : undefined
     }
 
+    /** Chain-tile coordinates at `now`. For smooth visual position use interpolatedPositionAt. */
     positionAt(now: Date): Coordinates {
         const taskIndex = this.sched.currentTaskIndex(now)
         const progress = this.sched.currentTaskProgress(now)
         return Coordinates.from(getPositionAt(this, taskIndex, progress))
     }
 
+    interpolatedPositionAt(now: Date): FloatPosition {
+        const taskIndex = this.sched.currentTaskIndex(now)
+        const progress = this.sched.currentTaskProgressFloat(now)
+        return getInterpolatedPosition(this, taskIndex, progress)
+    }
+
     isInFlight(now: Date): boolean {
         return schedule.isInFlight(this, now)
     }

package/src/entities/slot-multiplier.ts

@@ -0,0 +1,21 @@
+import type {EntitySlot} from '../data/recipes-runtime'
+
+export const U16_MAX = 65535
+
+export interface InstalledModule {
+    slotIndex: number
+    itemId: number
+    stats: bigint
+}
+
+export function clampUint16(value: number): number {
+    return Math.min(value, U16_MAX)
+}
+
+export function applySlotMultiplier(value: number, outputPct: number): number {
+    return clampUint16(Math.floor((value * outputPct) / 100))
+}
+
+export function getSlotAmp(layout: EntitySlot[], slotIndex: number): number {
+    return layout[slotIndex]?.outputPct ?? 100
+}

package/src/entities/warehouse.ts

@@ -10,6 +10,8 @@ import type {PackedModuleInput} from './ship'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 import {getModuleCapabilityType, MODULE_LOADER} from '../capabilities/modules'
 import {computeLoaderCapabilities} from './ship-deploy'
+import {applySlotMultiplier, clampUint16, getSlotAmp, type InstalledModule} from './slot-multiplier'
+import type {EntitySlot} from '../data/recipes-runtime'
 
 export interface WarehouseStateInput {
     id: UInt64Type
@@ -31,6 +33,14 @@ export class Warehouse extends ServerContract.Types.entity_info {
         return this.entity_name
     }
 
+    get entityClass(): 'building' {
+        return 'building'
+    }
+
+    get canDemolish(): boolean {
+        return true
+    }
+
     get inv(): InventoryAccessor {
         this._inv ??= new InventoryAccessor(this)
         return this._inv
@@ -96,7 +106,10 @@ export class Warehouse extends ServerContract.Types.entity_info {
     }
 }
 
-export function computeWarehouseCapabilities(modules: {itemId: number; stats: bigint}[]): {
+export function computeWarehouseCapabilities(
+    modules: InstalledModule[],
+    layout: EntitySlot[]
+): {
     loaders?: {mass: number; thrust: number; quantity: number}
 } {
     const warehouse: {loaders?: {mass: number; thrust: number; quantity: number}} = {}
@@ -109,10 +122,14 @@ export function computeWarehouseCapabilities(modules: {itemId: number; stats: bi
         for (const m of loaderModules) {
             const caps = computeLoaderCapabilities(decodeCraftedItemStats(m.itemId, m.stats))
             totalMass += caps.mass
-            totalThrust += caps.thrust
+            totalThrust += applySlotMultiplier(caps.thrust, getSlotAmp(layout, m.slotIndex))
             totalQuantity += caps.quantity
         }
-        warehouse.loaders = {mass: totalMass, thrust: totalThrust, quantity: totalQuantity}
+        warehouse.loaders = {
+            mass: totalMass,
+            thrust: clampUint16(totalThrust),
+            quantity: totalQuantity,
+        }
     }
 
     return warehouse

package/src/index-module.ts

@@ -16,9 +16,11 @@ 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, makeContainer} from './entities/makers'
+export {makeShip, makeWarehouse, makeExtractor, makeContainer} from './entities/makers'
 
 export type movement_stats = ServerContract.Types.movement_stats
 export type energy_stats = ServerContract.Types.energy_stats
@@ -26,14 +28,11 @@ export type loader_stats = ServerContract.Types.loader_stats
 export type schedule = ServerContract.Types.schedule
 export type task = ServerContract.Types.task
 export type cargo_item = ServerContract.Types.cargo_item
-export type warehouse_row = ServerContract.Types.warehouse_row
-export type container_row = ServerContract.Types.container_row
+export type entity_row = ServerContract.Types.entity_row
 export type gatherer_stats = ServerContract.Types.gatherer_stats
 
 export type location_static = ServerContract.Types.location_static
-export type location_epoch = ServerContract.Types.location_epoch
 export type location_derived = ServerContract.Types.location_derived
-export type location_row = ServerContract.Types.location_row
 export {Player} from './entities/player'
 export type {PlayerStateInput} from './entities/player'
 export {EntityInventory} from './entities/entity-inventory'
@@ -63,7 +62,6 @@ export {
     categoryLabel,
     categoryFromIndex,
     categoryLabelFromIndex,
-    tierLabel,
 } from './data/catalog'
 export {getCurrentEpoch, getEpochInfo} from './scheduling/epoch'
 export type {EpochInfo} from './scheduling/epoch'
@@ -73,8 +71,8 @@ export {
     getLocationType,
     getLocationTypeName,
     isGatherableLocation,
+    isLocationBuildable,
     deriveLocationStatic,
-    deriveLocationEpoch,
     deriveLocation,
 } from './utils/system'
 
@@ -86,6 +84,7 @@ export {
     getEligibleResources,
     getResourceWeight,
     getLocationCandidates,
+    getLocationProfile,
     getDepthThreshold,
     getResourceTier,
     DEPTH_THRESHOLD_T1,
@@ -117,30 +116,35 @@ export {
     distanceBetweenCoordinates,
     distanceBetweenPoints,
     findNearbyPlanets,
-    lerp,
-    rotation,
-    calc_ship_mass,
     calc_acceleration,
+    calc_energyusage,
     calc_flighttime,
-    calc_ship_flighttime,
-    calc_ship_acceleration,
-    calc_rechargetime,
-    calc_ship_rechargetime,
-    calc_loader_flighttime,
     calc_loader_acceleration,
-    calc_energyusage,
+    calc_loader_flighttime,
     calc_orbital_altitude,
+    calc_rechargetime,
+    calc_ship_acceleration,
+    calc_ship_flighttime,
+    calc_ship_mass,
+    calc_ship_rechargetime,
     calc_transfer_duration,
-    calculateTransferTime,
+    calculateFlightTime,
     calculateLoadTimeBreakdown,
     calculateRefuelingTime,
-    calculateFlightTime,
-    estimateTravelTime,
+    calculateTransferTime,
+    easeFlightProgress,
     estimateDealTravelTime,
-    hasEnergyForDistance,
-    getFlightOrigin,
+    estimateTravelTime,
+    flightSpeedFactor,
+    type FloatPosition,
     getDestinationLocation,
+    getFlightOrigin,
+    getInterpolatedPosition,
     getPositionAt,
+    hasEnergyForDistance,
+    interpolateFlightPosition,
+    lerp,
+    rotation,
 } from './travel/travel'
 export type {
     LoadTimeBreakdown,
@@ -159,6 +163,8 @@ export type {HasCargo} from './entities/inventory-accessor'
 export * as cargoUtils from './entities/cargo-utils'
 export type {CargoData} from './entities/cargo-utils'
 
+export {cargoRef, cargoItem} from './utils/cargo'
+
 export {
     createProjectedEntity,
     projectEntity,
@@ -174,14 +180,35 @@ export type {
     ProjectionOptions,
 } from './scheduling/projection'
 
+export {taskCargoChanges} from './scheduling/task-cargo'
+export type {TaskCargoChange, TaskCargoDirection} from './scheduling/task-cargo'
+
 export * from './types/capabilities'
 export * from './types/entity'
+export {
+    EntityClass,
+    ENTITY_SHIP,
+    ENTITY_WAREHOUSE,
+    ENTITY_EXTRACTOR,
+    ENTITY_CONTAINER,
+    shipTraits,
+    warehouseTraits,
+    extractorTraits,
+    containerTraits,
+    getEntityClass,
+    getPackedEntityType,
+    getEntityTraits,
+    isShip,
+    isWarehouse,
+    isExtractor,
+    isContainer,
+} from './types/entity-traits'
+export type {EntityTraits, EntityTypeName} from './types/entity-traits'
 export * from './capabilities'
 
 export {
     categoryColors,
     tierColors,
-    tierLabels,
     categoryIcons,
     categoryIconShapes,
     componentIcon,
@@ -202,14 +229,19 @@ export type {PlanetSubtypeInfo} from './data/locations'
 export {
     capabilityNames,
     capabilityAttributes,
-    statMappings,
     isInvertedAttribute,
     getCapabilityAttributes,
+} from './data/capabilities'
+export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+
+export {
+    deriveStatMappings,
     getStatMappings,
     getStatMappingsForStat,
     getStatMappingsForCapability,
-} from './data/capabilities'
-export type {CapabilityAttribute, StatMapping} from './data/capabilities'
+} from './derivation/capability-mappings'
+export {SLOT_FORMULAS} from './data/capability-formulas'
+export type {SlotConsumer, SlotConsumerKind} from './data/capability-formulas'
 
 export {
     encodeStats,
@@ -241,8 +273,11 @@ export {
     computeWarehouseHullCapabilities,
     computeStorageCapabilities,
     computeShipCapabilities,
+    GATHERER_DEPTH_TABLE,
+    GATHERER_DEPTH_MAX_TIER,
+    gathererDepthForTier,
 } from './entities/ship-deploy'
-export type {ShipCapabilities} from './entities/ship-deploy'
+export type {ShipCapabilities, GathererDepthParams} from './entities/ship-deploy'
 
 export {resolveItem} from './resolution/resolve-item'
 export type {
@@ -282,6 +317,9 @@ export type {
     NFTCommonBase,
 } from './nft/deserializers'
 
+export {deserializeAtomicData} from './nft/atomicdata'
+export type {SchemaField, RawData} from './nft/atomicdata'
+
 export {
     buildEntityDescription,
     formatModuleLine,
@@ -302,6 +340,9 @@ export {
     computeLoaderThrust,
     computeCrafterSpeed,
     computeCrafterDrain,
+    computeHaulerCapacity,
+    computeHaulerEfficiency,
+    computeWarpRange,
 } from './nft/description'
 
 export {