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

package/src/entities/gamestate.ts

@@ -58,13 +58,6 @@ export class GameState extends ServerContract.Types.state_row {
         return this.enabled
     }
 
-    /**
-     * Get the total number of ships in the game
-     */
-    get shipCount(): number {
-        return Number(this.ships)
-    }
-
     /**
      * Get the current salt value (used for random number generation)
      */
@@ -137,14 +130,12 @@ export class GameState extends ServerContract.Types.state_row {
     get summary(): {
         enabled: boolean
         epoch: string
-        ships: number
         hasSeed: boolean
         hasCommit: boolean
     } {
         return {
             enabled: this.enabled,
             epoch: this.epoch.toString(),
-            ships: this.shipCount,
             hasSeed: !this.seed.equals(Checksum256.from('0'.repeat(64))),
             hasCommit: !this.commit.equals(Checksum256.from('0'.repeat(64))),
         }

package/src/entities/makers.ts

@@ -3,8 +3,16 @@ 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 {getEntityLayout} from '../data/recipes-runtime'
+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 {itemMetadata} from '../data/metadata'
 import {getItem} from '../data/catalog'
 import {
@@ -14,6 +22,7 @@ import {
     moduleSlotTypeToCode,
 } from '../capabilities/modules'
 import {computeShipCapabilities, computeStorageCapabilities} from './ship-deploy'
+import type {InstalledModule} from './slot-multiplier'
 import {decodeCraftedItemStats} from '../derivation/crafting'
 
 function assignModulesToSlots(
@@ -56,19 +65,22 @@ 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()),
-    }
+function toInstalledModules(entries: ServerContract.Types.module_entry[]): InstalledModule[] {
+    const installed: InstalledModule[] = []
+    entries.forEach((entry, slotIndex) => {
+        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()),
+        })
+    })
+    return installed
 }
 
-function computeStorageBonus(
-    decoded: {itemId: number; stats: bigint}[],
-    baseCapacity: number
-): number {
+function computeStorageBonus(modules: InstalledModule[], baseCapacity: number): number {
     let totalBonus = 0
-    for (const m of decoded) {
+    for (const m of modules) {
         if (getModuleCapabilityType(m.itemId) !== MODULE_STORAGE) continue
         const stats = decodeCraftedItemStats(m.itemId, m.stats)
         const {capacityBonus} = computeStorageCapabilities(stats, baseCapacity)
@@ -78,15 +90,16 @@ function computeStorageBonus(
 }
 
 function deriveShipFromModules(
-    modules: PackedModuleInput[],
+    moduleEntries: ServerContract.Types.module_entry[],
+    layout: EntitySlot[],
     baseCapacity: number
 ): {
     capabilities: ReturnType<typeof computeShipCapabilities>
     finalCapacity: number
 } {
-    const decoded = modules.map(decodePackedInput)
-    const capabilities = computeShipCapabilities(decoded)
-    const totalBonus = computeStorageBonus(decoded, baseCapacity)
+    const installed = toInstalledModules(moduleEntries)
+    const capabilities = computeShipCapabilities(installed, layout)
+    const totalBonus = computeStorageBonus(installed, baseCapacity)
     return {capabilities, finalCapacity: baseCapacity + totalBonus}
 }
 
@@ -109,10 +122,12 @@ export function makeShip(state: ShipStateInput): Ship {
     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(
-            state.modules,
+            moduleEntries,
+            shipLayout,
             state.capacity ?? 0
         )
         if (capabilities.engines) info.engines = capabilities.engines
@@ -152,17 +167,18 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     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 decoded = state.modules.map(decodePackedInput)
-        const capabilities = computeWarehouseCapabilities(decoded)
+        const installed = toInstalledModules(moduleEntries)
+        const capabilities = computeWarehouseCapabilities(installed, warehouseLayout)
         if (capabilities.loaders) info.loaders = capabilities.loaders
 
-        const totalBonus = computeStorageBonus(decoded, state.capacity)
+        const totalBonus = computeStorageBonus(installed, state.capacity)
         info.capacity = UInt32.from(state.capacity + totalBonus)
     } else {
         moduleEntries = assignModulesToSlots(ITEM_WAREHOUSE_T1_PACKED, [], 'Warehouse T1')
@@ -174,6 +190,82 @@ export function makeWarehouse(state: WarehouseStateInput): Warehouse {
     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
+    }
+
+    info.modules = moduleEntries
+
+    const entityInfo = ServerContract.Types.entity_info.from(info)
+    return new Extractor(entityInfo)
+}
+
+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)
+
+    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
+    }
+
+    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'),
@@ -194,3 +286,21 @@ export function makeContainer(state: ContainerStateInput): Container {
     })
     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)
+}

package/src/entities/nexus.ts

@@ -0,0 +1,29 @@
+import type {UInt64Type} from '@wharfkit/antelope'
+import {ServerContract} from '../contracts'
+import type {CoordinatesType} from '../types'
+import {Location} from './location'
+
+export interface NexusStateInput {
+    id: UInt64Type
+    owner: string
+    name: string
+    coordinates: CoordinatesType | {x: number; y: number; z?: number}
+}
+
+export class Nexus extends ServerContract.Types.entity_info {
+    get name(): string {
+        return this.entity_name
+    }
+
+    get entityClass(): 'orbital' {
+        return 'orbital'
+    }
+
+    get location(): Location {
+        return Location.from(this.coordinates)
+    }
+
+    get orbitalAltitude(): number {
+        return this.coordinates.z?.toNumber() || 0
+    }
+}

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(): 'orbital' {
+        return 'orbital'
+    }
+
+    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
+}